a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
221}
222
223mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
228}
229
231{
232 return myNPbase->mueeZllH(sqrt_s);
233}
234
235mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
240}
241
243{
245}
246
247mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
252}
253
255{
256 return myNPbase->mueeZqqH(sqrt_s);
257}
258
259mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
264}
265
267{
269}
270
271
272aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
273: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
274{
275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
276 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
277}
278
280{
282}
283
284
285bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
287{
288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
289 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
290}
291
293{
295}
296
297
298muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
300{
301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
302 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
303}
304
306{
307 return myNPbase->muVH(sqrt_s);
308}
309
310muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVHpT250(sqrt_s);
320}
321
322muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVBFpVH(sqrt_s);
332}
333
334muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muttH(sqrt_s);
344}
345
346mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->mutHq(sqrt_s);
356}
357
358muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->muggHpttH(sqrt_s);
368}
369
370mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
375
376}
377
379{
380 return myNPbase->mueettH(sqrt_s);
381}
382
383mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
385{
386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
387 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
388}
389
391{
393}
394
395mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
400}
401
403{
404 return myNPbase->mummH(sqrt_s);
405}
406
407mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummHNWA(sqrt_s);
417}
418
419// -----------------------------------------------------------------------------
420// Decay widths
421// -----------------------------------------------------------------------------
422
424: ThObservable(SM_i)
425{
426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
427 throw std::runtime_error("GammaHtoggRatio called with a class whose parent is not NPbase");
428}
429
431{
432 return myNPbase->GammaHggRatio();
433}
434
436: ThObservable(SM_i)
437{
438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
439 throw std::runtime_error("GammaHtoWWRatio called with a class whose parent is not NPbase");
440}
441
443{
444 return myNPbase->GammaHWWRatio();
445}
446
448: ThObservable(SM_i)
449{
450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
451 throw std::runtime_error("GammaHtoZZRatio called with a class whose parent is not NPbase");
452}
453
455{
456 return myNPbase->GammaHZZRatio();
457}
458
460{
461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
462 throw std::runtime_error("GammaHtoZgaRatio called with a class whose parent is not NPbase");
463}
464
466{
467 return myNPbase->GammaHZgaRatio();
468}
469
471{
472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
473 throw std::runtime_error("GammaHtogagaRatio called with a class whose parent is not NPbase");
474}
475
477{
478 return myNPbase->GammaHgagaRatio();
479}
480
482{
483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
484 throw std::runtime_error("GammaHtomumuRatio called with a class whose parent is not NPbase");
485}
486
488{
489 return myNPbase->GammaHmumuRatio();
490}
491
493{
494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
495 throw std::runtime_error("GammaHtotautauRatio called with a class whose parent is not NPbase");
496}
497
499{
500 return myNPbase->GammaHtautauRatio();
501}
502
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("GammaHtossRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->GammaHssRatio();
512}
513
515{
516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
517 throw std::runtime_error("GammaHtoccRatio called with a class whose parent is not NPbase");
518}
519
521{
522 return myNPbase->GammaHccRatio();
523}
524
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("GammaHtobbRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->GammaHbbRatio();
534}
535
537: ThObservable(SM_i)
538{
539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
540 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
541}
542
544{
546}
547
548// -----------------------------------------------------------------------------
549// Branching Ratios
550// -----------------------------------------------------------------------------
551
553{
554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
555 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
556}
557
559{
560 return myNPbase->BrHtoinvRatio();
561}
562
564: ThObservable(SM_i)
565{
566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
567 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
568}
569
571{
572 return myNPbase->Br_H_inv();
573}
574
576: ThObservable(SM_i)
577{
578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
579 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
580}
581
583{
584 return myNPbase->Br_H_inv_NP();
585}
586
588: ThObservable(SM_i)
589{
590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
591 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
592}
593
595{
596 return myNPbase->Br_H_exo();
597}
598
600: ThObservable(SM_i)
601{
602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
603 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
604}
605
607{
608 return myNPbase->BrHvisRatio();
609}
610
612: ThObservable(SM_i)
613{
614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
615 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
616}
617
619{
620 return myNPbase->BrHggRatio();
621}
622
624: ThObservable(SM_i)
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHWWRatio();
633}
634
636: ThObservable(SM_i)
637{
638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
639 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
640}
641
643{
644 return myNPbase->BrHZZRatio();
645}
646
648: ThObservable(SM_i)
649{
650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
651 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
652}
653
655{
656 return myNPbase->BrHVVRatio();
657}
658
660{
661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
662 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
663}
664
666{
667 return myNPbase->BrHZgaRatio();
668}
669
671{
672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
673 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
674}
675
677{
678 return myNPbase->BrHZgallRatio();
679}
680
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
685}
686
688{
689 return myNPbase->BrHZgaeeRatio();
690}
691
693{
694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
695 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
696}
697
699{
700 return myNPbase->BrHZgamumuRatio();
701}
702
704{
705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
706 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
707}
708
710{
711 return myNPbase->BrHgagaRatio();
712}
713
715{
716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
717 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
718}
719
721{
722 return myNPbase->BrHmumuRatio();
723}
724
726{
727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
728 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
729}
730
732{
733 return myNPbase->BrHtautauRatio();
734}
735
737{
738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
739 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
740}
741
743{
744 return myNPbase->BrHccRatio();
745}
746
748{
749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
750 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
751}
752
754{
755 return myNPbase->BrHbbRatio();
756}
757
758// -----------------------------------------------------------------------------
759// More 4 fermion decays
760// -----------------------------------------------------------------------------
761
762
764: ThObservable(SM_i)
765{
766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
767 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
768}
769
771{
772 return myNPbase->BrH2l2vRatio();
773}
774
775
777: ThObservable(SM_i)
778{
779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
780 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
781}
782
784{
785 return myNPbase->BrHevmuvRatio();
786}
787
788
790: ThObservable(SM_i)
791{
792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
793 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
794}
795
797{
798 // SM decay widths (from MG simulations)
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
800
801 // Sum
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
803
804 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
805}
806
807
809: ThObservable(SM_i)
810{
811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
812 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
813}
814
816{
817 // SM decay widths (from MG simulations)
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
819
820 // Sum
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
822
823 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
824}
825
826
828: ThObservable(SM_i)
829{
830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
831 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
832}
833
835{
836 return myNPbase->BrH4lRatio();
837}
838
839
841: ThObservable(SM_i)
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
845}
846
848{
849 return myNPbase->BrH4eRatio();
850}
851
852
854: ThObservable(SM_i)
855{
856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
857 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
858}
859
861{
862 return myNPbase->BrH4muRatio();
863}
864
865
867: ThObservable(SM_i)
868{
869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
870 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
871}
872
874{
875 return myNPbase->BrH2e2muRatio();
876}
877
878
879
881: ThObservable(SM_i)
882{
883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
884 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
885}
886
888{
889 return myNPbase->BrHlljjRatio();
890}
891
892
894: ThObservable(SM_i)
895{
896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
897 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
898}
899
901{
902 return myNPbase->BrHlvjjRatio();
903}
904
905
907: ThObservable(SM_i)
908{
909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
910 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
911}
912
914{
915 return myNPbase->BrHlv_lvorjjRatio();
916}
917
918
920: ThObservable(SM_i)
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
924}
925
927{
928 return myNPbase->BrHll_vvorjjRatio();
929}
930
931// -----------------------------------------------------------------------------
932// Ratios of BR (ratios with SM)
933// -----------------------------------------------------------------------------
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
945 } else {
946 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
960 } else {
961 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
975 } else {
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
990 } else {
991 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
1005 } else {
1006 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
1007 }
1008}
1009
1010
1012{
1013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1014 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1015}
1016
1018{
1019 if ((this->getModel()).isModelLinearized()) {
1020 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
1021 } else {
1022 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
1023 }
1024}
1025
1026
1028{
1029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1030 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1031}
1032
1034{
1035 if ((this->getModel()).isModelLinearized()) {
1036 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
1037 } else {
1038 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
1039 }
1040}
1041
1042
1044{
1045 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1046 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1047}
1048
1050{
1051 if ((this->getModel()).isModelLinearized()) {
1052 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
1053 } else {
1054 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
1055 }
1056}
1057
1059{
1060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1061 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1062}
1063
1065{
1066 if ((this->getModel()).isModelLinearized()) {
1067 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
1068 } else {
1069 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
1070 }
1071}
1072
1074{
1075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1076 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1077}
1078
1080{
1081 if ((this->getModel()).isModelLinearized()) {
1082 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
1083 } else {
1084 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
1085 }
1086}
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
1098 } else {
1099 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
1100 }
1101}
1102
1104{
1105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1106 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1107}
1108
1110{
1111 if ((this->getModel()).isModelLinearized()) {
1112 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1113 } else {
1114 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1115 }
1116}
1117
1119{
1120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1121 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1122}
1123
1125{
1126 if ((this->getModel()).isModelLinearized()) {
1127 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1128 } else {
1129 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1130 }
1131}
1132
1134{
1135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1136 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1137}
1138
1140{
1141 if ((this->getModel()).isModelLinearized()) {
1142 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1143 } else {
1144 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1145 }
1146}
1147
1148
1150{
1151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1152 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1153}
1154
1156{
1157 if ((this->getModel()).isModelLinearized()) {
1158 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1159 } else {
1160 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1161 }
1162}
1163
1164
1166{
1167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1168 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1169}
1170
1172{
1173 if ((this->getModel()).isModelLinearized()) {
1174 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1175 } else {
1176 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1177 }
1178}
1179
1180
1182{
1183 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1184 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1185}
1186
1188{
1189 if ((this->getModel()).isModelLinearized()) {
1190 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1191 } else {
1192 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1193 }
1194}
1195
1196
1198{
1199 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1200 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1201}
1202
1204{
1205 if ((this->getModel()).isModelLinearized()) {
1206 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1207 } else {
1208 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1209 }
1210}
1211
1212
1214{
1215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1216 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1217}
1218
1220{
1221 if ((this->getModel()).isModelLinearized()) {
1222 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1223 } else {
1224 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1225 }
1226}
1227
1228
1229// -----------------------------------------------------------------------------
1230// Full signal strengths (prod x decay)
1231// -----------------------------------------------------------------------------
1232
1233muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1234: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1235{
1236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1237 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1238}
1239
1241{
1242 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1243 //AG: Most general expression including quadratic corrections.
1244 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1245 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1246 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1247 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1248 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1249 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1250
1251 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1252 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1253 double Br1 = dGammaR1-dGammaRTot1;
1254 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1255 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1256 } else {
1257 return myNPbase->muggHgaga(sqrt_s);
1258 }
1259}
1260
1261muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1262: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1263{
1264 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1265 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1266}
1267
1269{
1271}
1272
1273muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1274: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1275{
1276 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1277 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1278}
1279
1281{
1282 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1283 //AG: Most general expression including quadratic corrections.
1284 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1285 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1286 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1287 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1288 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1289 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1290
1291 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1292 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1293 double Br1 = dGammaR1-dGammaRTot1;
1294 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1295
1296 double mu;
1297
1298 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1299
1300 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1301
1302 return mu;
1303 } else {
1304 return myNPbase->muVBFHgaga(sqrt_s);
1305 }
1306}
1307
1308muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1309: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1310{
1311 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1312 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1313}
1314
1316{
1317 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1318 //AG: Most general expression including quadratic corrections.
1319 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1320 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1321 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1322 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1323 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1324 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1325
1326 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1327 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1328 double Br1 = dGammaR1-dGammaRTot1;
1329 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1330
1331 double mu;
1332
1333 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1334
1335 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1336
1337 return mu;
1338
1339 } else {
1340 return myNPbase->muZHgaga(sqrt_s);
1341 }
1342}
1343
1344muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1346{
1347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1348 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1349}
1350
1352{
1353 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1354 //AG: Most general expression including quadratic corrections.
1355 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1356 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1357 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1358 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1359 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1360 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1361
1362 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1363 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1364 double Br1 = dGammaR1-dGammaRTot1;
1365 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1366
1367 double mu;
1368
1369 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1370
1371 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1372
1373 return mu;
1374
1375 } else {
1376 return myNPbase->muWHgaga(sqrt_s);
1377 }
1378}
1379
1380muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1381: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1382{
1383 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1384 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1385}
1386
1388{
1389 if ((this->getModel()).isModelLinearized()) {
1390 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1391 } else {
1392 return myNPbase->muVHgaga(sqrt_s);
1393 }
1394}
1395
1396muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1397: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1398{
1399 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1400 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1401}
1402
1404{
1405 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1406 //AG: Most general expression including quadratic corrections.
1407 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1408 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1409 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1410 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1411 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1412 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1413
1414 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1415 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1416 double Br1 = dGammaR1-dGammaRTot1;
1417 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1418
1419 double mu;
1420
1421 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1422
1423 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1424
1425 return mu;
1426
1427 } else {
1428 return myNPbase->muttHgaga(sqrt_s);
1429 }
1430}
1431
1432mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1433: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1434{
1435 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1436 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1437}
1438
1440{
1441 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1442 //AG: Most general expression including quadratic corrections.
1443 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1444 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1445 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1446 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1447 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1448
1449 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1450 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1451 double Br1 = dGammaR1-dGammaRTot1;
1452 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1453
1454 double mu;
1455
1456 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1457
1458 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1459
1460 return mu;
1461
1462 } else {
1463 //VM: Just in case someone wants to add directly the production*decay
1464 //(which is the observable we fit at the end)
1465 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1466 if(NPmutHgaga==1.0){
1467 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1468 } else{
1469 return NPmutHgaga;
1470 }
1471 }
1472}
1473
1474muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1475: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1476{
1477 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1478 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1479}
1480
1482{
1483 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1484 //AG: Most general expression including quadratic corrections.
1485 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1486 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1487 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1488 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1489 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1490
1491 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1492 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1493 double Br1 = dGammaR1-dGammaRTot1;
1494 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1495
1496 double mu;
1497
1498 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1499
1500 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1501
1502 return mu;
1503
1504 } else {
1505 //VM: Just in case someone wants to add directly the production*decay
1506 //(which is the observable we fit at the end)
1507 //Also, the bbH is missing here, I'll leave it as it was for the
1508 //moment (since bbH is really suppressed).
1509 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1510 if (NPmuggHpbbH_Hgaga == 1.0){
1511 return (myNPbase->muggHgaga(sqrt_s));
1512 } else{
1513 return NPmuggHpbbH_Hgaga;
1514 }
1515 }
1516}
1517
1518muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1519: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1520{
1521 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1522 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1523}
1524
1526{
1527 //VM:Note that these values are valid for 13 TeV, they are not general
1528 //We should access the SM function that has all the values (for the
1529 //different energies). The values are slightly different, we should
1530 //check this.
1531 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1532 double xsSM_ttH = 0.499873;
1533 double xsSM_tH = 0.0821;
1534 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1535 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1536
1537 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1538 //AG: Most general expression including quadratic corrections.
1539 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1540 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1541 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1542 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1543 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1544
1545 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1546 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1547 double Br1 = dGammaR1-dGammaRTot1;
1548 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1549
1550 double mu;
1551
1552 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1553
1554 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1555
1556 return mu;
1557
1558 } else {
1559 //VM: Just in case someone wants to add directly the production*decay
1560 //(which is the observable we fit at the end)
1561 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1562 if(NPmuttHptH_Hgaga==1.0){
1563 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1564 } else {
1565 return NPmuttHptH_Hgaga;
1566 }
1567 }
1568}
1569
1570muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1571: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1572{
1573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1574 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1575}
1576
1578{
1579 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1580 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1581 //AG: Most general expression including quadratic corrections.
1582 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1583 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1584 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1585 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1586 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1587
1588 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1589 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1590 double Br1 = dGammaR1-dGammaRTot1;
1591 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1592
1593 double mu;
1594
1595 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1596
1597 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1598
1599 return mu;
1600
1601 } else {
1602 return myNPbase->muggHZga(sqrt_s);
1603 }
1604}
1605
1606muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1607: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1608{
1609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1610 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1611}
1612
1614{
1615 if ((this->getModel()).isModelLinearized()) {
1616 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1617 } else {
1619 }
1620}
1621
1622muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1623: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1624{
1625 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1626 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1627}
1628
1630{
1631 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1632 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1633 //AG: Most general expression including quadratic corrections.
1634 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1635 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1636 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1637 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1638 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1639
1640 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1641 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1642 double Br1 = dGammaR1-dGammaRTot1;
1643 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1644
1645 double mu;
1646
1647 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1648
1649 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1650
1651 return mu;
1652
1653 } else {
1654 return myNPbase->muVBFHZga(sqrt_s);
1655 }
1656}
1657
1658muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1659: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1660{
1661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1662 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1663}
1664
1666{
1667 if ((this->getModel()).isModelLinearized()) {
1668 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1669 } else {
1670 return myNPbase->muZHZga(sqrt_s);
1671 }
1672}
1673
1674muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1675: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1676{
1677 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1678 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1679}
1680
1682{
1683 if ((this->getModel()).isModelLinearized()) {
1684 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1685 } else {
1686 return myNPbase->muWHZga(sqrt_s);
1687 }
1688}
1689
1690muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1691: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1692{
1693 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1694 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1695}
1696
1698{
1699 if ((this->getModel()).isModelLinearized()) {
1700 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1701 } else {
1702 return myNPbase->muVHZga(sqrt_s);
1703 }
1704}
1705
1706muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1707: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1708{
1709 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1710 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1711}
1712
1714{
1715 if ((this->getModel()).isModelLinearized()) {
1716 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1717 } else {
1718 return myNPbase->muttHZga(sqrt_s);
1719 }
1720}
1721
1722muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1723: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1724{
1725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1726 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1727}
1728
1730{
1731 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1732 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1733 //AG: Most general expression including quadratic corrections.
1734 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1735 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1736 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1737 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1738 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1739
1740 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1741 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1742 double Br1 = dGammaR1-dGammaRTot1;
1743 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1744
1745 double mu;
1746
1747 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1748
1749 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1750
1751 return mu;
1752
1753 } else {
1754 return myNPbase->muggHZZ(sqrt_s);
1755 }
1756}
1757
1758muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1759: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1760{
1761 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1762 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1763}
1764
1766{
1767 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1768 //AG: Most general expression including quadratic corrections.
1769 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1770 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1771 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1772 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1773 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1774 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1775
1776 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1777 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1778 double Br1 = dGammaR1-dGammaRTot1;
1779 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1780
1781 double mu;
1782
1783 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1784
1785 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1786
1787 return mu;
1788
1789 } else {
1790 return myNPbase->muVBFHZZ(sqrt_s);
1791 }
1792}
1793
1794muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1795: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1796{
1797 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1798 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1799}
1800
1802{
1803 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1804 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1805 //AG: Most general expression including quadratic corrections.
1806 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1807 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1808 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1809 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1810 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1811
1812 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1813 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1814 double Br1 = dGammaR1-dGammaRTot1;
1815 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1816
1817 double mu;
1818
1819 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1820
1821 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1822
1823 return mu;
1824
1825 } else {
1826 return myNPbase->muZHZZ(sqrt_s);
1827 }
1828}
1829
1830muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1831: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1832{
1833 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1834 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1835}
1836
1838{
1839 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1840 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1841 //AG: Most general expression including quadratic corrections.
1842 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1843 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1844 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1845 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1846 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1847
1848 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1849 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1850 double Br1 = dGammaR1-dGammaRTot1;
1851 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1852
1853 double mu;
1854
1855 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1856
1857 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1858
1859 return mu;
1860
1861 } else {
1862 return myNPbase->muWHZZ(sqrt_s);
1863 }
1864}
1865
1866muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1867: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1868{
1869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1870 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1871}
1872
1874{
1875 //VM:Note that these values are valid for 13 TeV, they are not general
1876 //We should access the SM function that has all the values (for the
1877 //different energies). The values are slightly different, we should
1878 //check this.
1879 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1880 double xsSM_WH = 1.21539;
1881 double xsSM_ZH = 0.795910;
1882 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1883 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1884 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1885 //AG: Most general expression including quadratic corrections.
1886 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1887 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1888 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1889 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1890 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1891 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1892
1893 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1894 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1895 double Br1 = dGammaR1-dGammaRTot1;
1896 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1897
1898 double mu;
1899
1900 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1901
1902 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1903
1904 return mu;
1905
1906 } else {
1907 //return myNPbase->muVHZZ(sqrt_s);
1908 //VM: Just in case someone wants to add directly the production*decay
1909 //(which is the observable we fit at the end)
1910 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1911 if(NPmuVHZZ==1.0){
1912 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1913 } else {
1914 return NPmuVHZZ;
1915 }
1916 }
1917}
1918
1919muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1920: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1921{
1922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1923 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1924}
1925
1927{
1928 if ((this->getModel()).isModelLinearized()) {
1929 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1930 } else {
1931 return myNPbase->muttHZZ(sqrt_s);
1932 }
1933}
1934
1935muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1936: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1937{
1938 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1939 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1940}
1941
1943{
1944 //VM:Note that these values are valid for 13 TeV, they are not general
1945 //We should access the SM function that has all the values (for the
1946 //different energies). The values are slightly different, we should
1947 //check this.
1948 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1949 double xsSM_ttH = 0.499873;
1950 double xsSM_tH = 0.0821;
1951 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1952 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1953 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1954 //AG: Most general expression including quadratic corrections.
1955 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1956 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1957 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1958 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1959 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1960 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1961
1962 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1963 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1964 double Br1 = dGammaR1-dGammaRTot1;
1965 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1966
1967 double mu;
1968
1969 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1970
1971 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1972
1973 return mu;
1974
1975 } else {
1976
1977 //VM: Just in case someone wants to add directly the production*decay
1978 //(which is the observable we fit at the end)
1979 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
1980 if(NPmuttHptH_HZZ==1.0){
1981 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
1982 } else {
1983 return NPmuttHptH_HZZ;
1984 }
1985 }
1986}
1987
1988muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1989: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1990{
1991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1992 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
1993}
1994
1996{
1997 //VM:Note that these values are valid for 13 TeV, they are not general
1998 //We should access the SM function that has all the values (for the
1999 //different energies). The values are slightly different, we should
2000 //check this.
2001 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2002 double xsSM_ttH = 0.499873;
2003 double xsSM_tH = 0.0821;
2004 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2005 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2006 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2007 //return ( 1.0
2008 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
2009 // + (myNPbase->BrHmumuRatio()-1.));
2010 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
2011 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2012 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2013 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2014
2015 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2016 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2017 double Br1 = dGammaR1-dGammaRTot1;
2018 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2019
2020 double mu;
2021
2022 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2023
2024 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2025
2026 return mu;
2027
2028 } else {
2029
2030 //VM: Just in case someone wants to add directly the production*decay
2031 //(which is the observable we fit at the end)
2032 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
2033 if(NPmuttHptH_Hmumu==1.0){
2034 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
2035 } else {
2036 return NPmuttHptH_Hmumu;
2037 }
2038 }
2039}
2040
2041muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2042: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2043{
2044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2045 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
2046}
2047
2049{
2050 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2051 //AG: Most general expression including quadratic corrections.
2052 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2053 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
2054 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2055 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2056 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2057 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2058
2059 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2060 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2061 double Br1 = dGammaR1-dGammaRTot1;
2062 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2063
2064 double mu;
2065
2066 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2067
2068 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2069
2070 return mu;
2071
2072 } else {
2073 //VM: Just in case someone wants to add directly the production*decay
2074 //(which is the observable we fit at the end)
2075 //Also, the bbH is missing here, I'll leave it as it was for the
2076 //moment (since bbH is really suppressed in the SM).
2077 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
2078 if (NPmuggHpbbH_HZZ == 1.0){
2079 return (myNPbase->muggHZZ(sqrt_s));
2080 } else{
2081 return NPmuggHpbbH_HZZ;
2082 }
2083 }
2084}
2085
2086muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2088{
2089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2090 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
2091}
2092
2094{
2095 if ((this->getModel()).isModelLinearized()) {
2096 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2097 } else {
2098 return myNPbase->muggHZZ4l(sqrt_s);
2099 }
2100}
2101
2102muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
2103: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2104{
2105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2106 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
2107}
2108
2110{
2111 if ((this->getModel()).isModelLinearized()) {
2112 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2113 } else {
2114 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2115 }
2116}
2117
2118muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2119: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2120{
2121 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2122 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2123}
2124
2126{
2127 if ((this->getModel()).isModelLinearized()) {
2128 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2129 } else {
2130 return myNPbase->muVBFHZZ4l(sqrt_s);
2131 }
2132}
2133
2134muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2135: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2136{
2137 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2138 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2139}
2140
2142{
2143 if ((this->getModel()).isModelLinearized()) {
2144 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2145 } else {
2146 return myNPbase->muZHZZ4l(sqrt_s);
2147 }
2148}
2149
2150muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2151: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2152{
2153 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2154 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2155}
2156
2158{
2159 if ((this->getModel()).isModelLinearized()) {
2160 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2161 } else {
2162 return myNPbase->muWHZZ4l(sqrt_s);
2163 }
2164}
2165
2166muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2167: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2168{
2169 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2170 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2171}
2172
2174{
2175 if ((this->getModel()).isModelLinearized()) {
2176 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2177 } else {
2178 return myNPbase->muVHZZ4l(sqrt_s);
2179 }
2180}
2181
2182muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2183: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2184{
2185 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2186 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2187}
2188
2190{
2191 if ((this->getModel()).isModelLinearized()) {
2192 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2193 } else {
2194 return myNPbase->muttHZZ4l(sqrt_s);
2195 }
2196}
2197
2198muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2199: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2200{
2201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2202 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2203}
2204
2206{
2207 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2208 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2209 //AG: Most general expression including quadratic corrections.
2210 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2211 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2212 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2213 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2214 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2215
2216 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2217 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2218 double Br1 = dGammaR1-dGammaRTot1;
2219 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2220
2221 double mu;
2222
2223 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2224
2225 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2226
2227 return mu;
2228
2229 } else {
2230 return myNPbase->muggHWW(sqrt_s);
2231 }
2232}
2233
2234muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2235: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2236{
2237 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2238 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2239}
2240
2242{
2243 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2244 //AG: Most general expression including quadratic corrections.
2245 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2246 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2247 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2248 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2249 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2250 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2251
2252 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2253 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2254 double Br1 = dGammaR1-dGammaRTot1;
2255 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2256
2257 double mu;
2258
2259 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2260
2261 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2262
2263 return mu;
2264
2265 } else {
2266 return myNPbase->muVBFHWW(sqrt_s);
2267 }
2268}
2269
2270muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2271: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2272{
2273 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2274 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2275}
2276
2278{
2279 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2280 //AG: Most general expression including quadratic corrections.
2281 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2282 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2283 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2284 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2285 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2286 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2287
2288 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2289 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2290 double Br1 = dGammaR1-dGammaRTot1;
2291 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2292
2293 double mu;
2294
2295 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2296
2297 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2298
2299 return mu;
2300
2301 } else {
2302 return myNPbase->muZHWW(sqrt_s);
2303 }
2304}
2305
2306muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2307: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2308{
2309 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2310 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2311}
2312
2314{
2315 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2316 //AG: Most general expression including quadratic corrections.
2317 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2318 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2319 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2320 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2321 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2322 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2323
2324 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2325 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2326 double Br1 = dGammaR1-dGammaRTot1;
2327 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2328
2329 double mu;
2330
2331 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2332
2333 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2334
2335 return mu;
2336
2337 } else {
2338 return myNPbase->muWHWW(sqrt_s);
2339 }
2340}
2341
2342muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2343: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2344{
2345 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2346 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2347}
2348
2350{
2351 if ((this->getModel()).isModelLinearized()) {
2352 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2353 } else {
2354 return myNPbase->muVHWW(sqrt_s);
2355 }
2356}
2357
2358muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2360{
2361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2362 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2363}
2364
2366{
2367 if ((this->getModel()).isModelLinearized()) {
2368 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2369 } else {
2370 return myNPbase->muttHWW(sqrt_s);
2371 }
2372}
2373
2374muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2375: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2376{
2377 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2378 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2379}
2380
2382{
2383
2384 //VM:Note that these values are valid for 13 TeV, they are not general
2385 //We should access the SM function that has all the values (for the
2386 //different energies). The values are slightly different, we should
2387 //check this.
2388 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2389 double xsSM_ttH = 0.499873;
2390 double xsSM_tH = 0.0821;
2391 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2392 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2393 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2394 //AG: Most general expression including quadratic corrections.
2395 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2396 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2397 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2398 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2399 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2400
2401 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2402 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2403 double Br1 = dGammaR1-dGammaRTot1;
2404 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2405
2406 double mu;
2407
2408 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2409
2410 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2411
2412 return mu;
2413
2414 } else {
2415
2416 //VM: Just in case someone wants to add directly the production*decay
2417 //(which is the observable we fit at the end)
2418 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2419 if(NPmuttHptH_HWW==1.0){
2420 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2421 } else {
2422 return NPmuttHptH_HWW;
2423 }
2424 }
2425}
2426
2427muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2428: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2429{
2430 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2431 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2432}
2433
2435{
2436 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2437 //AG: Most general expression including quadratic corrections.
2438 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2439 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2440 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2441 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2442 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2443 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2444
2445 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2446 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2447 double Br1 = dGammaR1-dGammaRTot1;
2448 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2449
2450 double mu;
2451
2452 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2453
2454 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2455
2456 return mu;
2457
2458 } else {
2459
2460 //VM: Just in case someone wants to add directly the production*decay
2461 //(which is the observable we fit at the end)
2462 //Also, the bbH is missing here, I'll leave it as it was for the
2463 //moment (since bbH is really suppressed in the SM).
2464 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2465 if (NPmuggHpbbH_HWW == 1.0){
2466 return (myNPbase->muggHWW(sqrt_s));
2467 } else{
2468 return NPmuggHpbbH_HWW;
2469 }
2470 }
2471}
2472
2473muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2474: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2475{
2476 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2477 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2478}
2479
2481{
2482 if ((this->getModel()).isModelLinearized()) {
2483 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2484 } else {
2485 return myNPbase->muggHWW2l2v(sqrt_s);
2486 }
2487}
2488
2489muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2491{
2492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2493 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2494}
2495
2497{
2498 if ((this->getModel()).isModelLinearized()) {
2499 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2500 } else {
2501 return myNPbase->muVBFHWW2l2v(sqrt_s);
2502 }
2503}
2504
2505muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2506: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2507{
2508 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2509 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2510}
2511
2513{
2514 if ((this->getModel()).isModelLinearized()) {
2515 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2516 } else {
2517 return myNPbase->muZHWW2l2v(sqrt_s);
2518 }
2519}
2520
2521muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2522: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2523{
2524 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2525 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2526}
2527
2529{
2530 if ((this->getModel()).isModelLinearized()) {
2531 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2532 } else {
2533 return myNPbase->muWHWW2l2v(sqrt_s);
2534 }
2535}
2536
2537muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2538: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2539{
2540 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2541 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2542}
2543
2545{
2546 if ((this->getModel()).isModelLinearized()) {
2547 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2548 } else {
2549 return myNPbase->muVHWW2l2v(sqrt_s);
2550 }
2551}
2552
2553muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2554: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2555{
2556 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2557 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2558}
2559
2561{
2562 if ((this->getModel()).isModelLinearized()) {
2563 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2564 } else {
2565 return myNPbase->muttHWW2l2v(sqrt_s);
2566 }
2567}
2568
2569muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2570: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2571{
2572 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2573 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2574}
2575
2577{
2578 if ((this->getModel()).isModelLinearized()) {
2579 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2580 } else {
2581 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2582 }
2583}
2584
2585muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2586: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2587{
2588 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2589 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2590}
2591
2593{
2594 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2595 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2596 //AG: Most general expression including quadratic corrections.
2597 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2598 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2599 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2600 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2601 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2602
2603 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2604 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2605 double Br1 = dGammaR1-dGammaRTot1;
2606 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2607
2608 double mu;
2609
2610 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2611
2612 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2613
2614 return mu;
2615
2616 } else {
2617 return myNPbase->muggHmumu(sqrt_s);
2618 }
2619}
2620
2621muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2622: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2623{
2624 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2625 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2626}
2627
2629{
2630 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2631 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2632 //AG: Most general expression including quadratic corrections.
2633 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2634 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2635 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2636 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2637 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2638
2639 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2640 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2641 double Br1 = dGammaR1-dGammaRTot1;
2642 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2643
2644 double mu;
2645
2646 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2647
2648 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2649
2650 return mu;
2651
2652 } else {
2653 return myNPbase->muVBFHmumu(sqrt_s);
2654 }
2655}
2656
2657muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2658: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2659{
2660 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2661 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2662}
2663
2665{
2666 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2667 //AG: Most general expression including quadratic corrections.
2668 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2669 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2670 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2671 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2672 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2673
2674 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2675 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2676 double Br1 = dGammaR1-dGammaRTot1;
2677 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2678
2679 double mu;
2680
2681 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2682
2683 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2684
2685 return mu;
2686
2687 } else {
2688 return myNPbase->muZHmumu(sqrt_s);
2689 }
2690}
2691
2692muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2694{
2695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2696 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2697}
2698
2700{
2701 if ((this->getModel()).isModelLinearized()) {
2702 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2703 } else {
2704 return myNPbase->muWHmumu(sqrt_s);
2705 }
2706}
2707
2708muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2709: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2710{
2711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2712 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2713}
2714
2716{
2717
2718 //VM:Note that these values are valid for 13 TeV, they are not general
2719 //We should access the SM function that has all the values (for the
2720 //different energies). The values are slightly different, we should
2721 //check this.
2722 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2723 double xsSM_WH = 1.21539;
2724 double xsSM_ZH = 0.795910;
2725 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2726 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2727 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2728 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2729 //AG: Most general expression including quadratic corrections.
2730 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2731 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2732 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2733 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2734 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2735
2736 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2737 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2738 double Br1 = dGammaR1-dGammaRTot1;
2739 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2740
2741 double mu;
2742
2743 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2744
2745 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2746
2747 return mu;
2748
2749 } else {
2750 //return myNPbase->muVHmumu(sqrt_s);
2751 //VM: Just in case someone wants to add directly the production*decay
2752 //(which is the observable we fit at the end)
2753 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2754 if(NPmuVHmumu==1.0){
2755 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2756 } else {
2757 return NPmuVHmumu;
2758 }
2759
2760 }
2761}
2762
2763muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2765{
2766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2767 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2768}
2769
2771{
2772 if ((this->getModel()).isModelLinearized()) {
2773 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2774 } else {
2775 return myNPbase->muttHmumu(sqrt_s);
2776 }
2777}
2778
2779muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2780: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2781{
2782 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2783 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2784}
2785
2787{
2788 //VM:Note that these values are valid for 13 TeV, they are not general
2789 //We should access the SM function that has all the values (for the
2790 //different energies). The values are slightly different, we should
2791 //check this. Furthermore, the bbH is not included. In the SM this is
2792 //very suppressed (and it's probably also the case in the SMEFT) but
2793 //in some NP models it may not be the case.Unfortunately, bbH is not
2794 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2795 //SMEFT and add here the general expression.
2796 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2797 double xsSM_ggHbbH = 44.745;
2798 double xsSM_ttH = 0.4998;
2799 double xsSM_tH = 0.084769;
2800 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2801 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2802 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2803 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2804
2805
2806
2807 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2808 //AG: Most general expression including quadratic corrections.
2809 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2810 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2811 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2812 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2813 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2814
2815 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2816 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2817 double Br1 = dGammaR1-dGammaRTot1;
2818 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2819
2820 double mu;
2821
2822 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2823
2824 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2825
2826 return mu;
2827
2828 } else {
2829
2830 //VM: Just in case someone wants to add directly the production*decay
2831 //(which is the observable we fit at the end). Furthermore, the Hbb
2832 //is not added in the original formula, fine for the SM (probably also
2833 //for the SMEFT) but not for all NP models.
2834 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2835 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2836 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2837 } else {
2838 return NPmuggHpttHptHpbbH_Hmumu;
2839 }
2840 }
2841}
2842
2843muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2845{
2846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2847 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2848}
2849
2851{
2852
2853 //VM:Note that these values are valid for 13 TeV, they are not general
2854 //We should access the SM function that has all the values (for the
2855 //different energies). The values are slightly different, we should
2856 //check this.
2857 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2858 double xsSM_VBF = 3.49948;
2859 double xsSM_WH = 1.21539;
2860 double xsSM_ZH = 0.795910;
2861 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2862 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2863 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2864 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2865 //AG: Most general expression including quadratic corrections.
2866 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2867 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2868 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2869 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2870 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2871
2872 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2873 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2874 double Br1 = dGammaR1-dGammaRTot1;
2875 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2876
2877 double mu;
2878
2879 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2880
2881 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2882
2883 return mu;
2884
2885 } else {
2886
2887 //VM: Just in case someone wants to add directly the production*decay
2888 //(which is the observable we fit at the end).
2889 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2890 if(NPmuVBFpVH_Hmumu==1.0){
2891 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2892 } else {
2893 return NPmuVBFpVH_Hmumu;
2894 }
2895 }
2896}
2897
2898muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2899: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2900{
2901 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2902 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2903}
2904
2906{
2907 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2908 //AG: Most general expression including quadratic corrections.
2909 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2910 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2911 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2912 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2913 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2914 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2915
2916 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2917 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2918 double Br1 = dGammaR1-dGammaRTot1;
2919 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2920
2921 double mu;
2922
2923 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2924
2925 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2926
2927 return mu;
2928
2929 } else {
2930 return myNPbase->muggHtautau(sqrt_s);
2931 }
2932}
2933
2934muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2935: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2936{
2937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2938 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2939}
2940
2942{
2943 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2944 //AG: Most general expression including quadratic corrections.
2945 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2946 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2947 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2948 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2949 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2950 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2951
2952 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2953 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2954 double Br1 = dGammaR1-dGammaRTot1;
2955 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2956
2957 double mu;
2958
2959 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2960
2961 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2962
2963 return mu;
2964
2965 } else {
2966 return myNPbase->muVBFHtautau(sqrt_s);
2967 }
2968}
2969
2970
2971
2972muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2974{
2975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2976 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
2977}
2978
2980{
2981 if ((this->getModel()).isModelLinearized()) {
2982 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2983 } else {
2985 }
2986}
2987
2988
2989muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2991{
2992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2993 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
2994}
2995
2996double muZHtautau::computeThValue() //AG:modified
2997{
2998 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2999 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3000 //AG: Most general expression including quadratic corrections.
3001 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3002 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3003 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3004 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3005 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3006 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3007
3008 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3009 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3010 double Br1 = dGammaR1-dGammaRTot1;
3011 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3012
3013 double mu;
3014
3015 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3016
3017 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3018
3019 return mu;
3020
3021 } else {
3022 return myNPbase->muZHtautau(sqrt_s);
3023 }
3024}
3025
3026muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3027: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3028{
3029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3030 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
3031}
3032
3034{
3035 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3036 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3037 //AG: Most general expression including quadratic corrections.
3038 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3039 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3040 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3041 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3042 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3043
3044 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3045 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3046 double Br1 = dGammaR1-dGammaRTot1;
3047 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3048
3049 /*std::cout << "muProd1="<<muProd1<<std::endl;
3050 std::cout << "muProd2="<<muProd2<<std::endl;
3051 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
3052 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
3053 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
3054 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
3055
3056 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
3057 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
3058
3059 double mu;
3060
3061 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3062
3063 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3064
3065 return mu;
3066
3067 } else {
3068 return myNPbase->muWHtautau(sqrt_s);
3069 }
3070}
3071
3072muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3073: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3074{
3075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3076 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
3077}
3078
3080{
3081 //VM:Note that these values are valid for 13 TeV, they are not general
3082 //We should access the SM function that has all the values (for the
3083 //different energies). The values are slightly different, we should
3084 //check this.
3085 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3086 double xsSM_WH = 1.21539;
3087 double xsSM_ZH = 0.795910;
3088 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3089 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3090 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3091 //AG: Most general expression including quadratic corrections.
3092 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3093 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3094 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3095 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3096 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3097 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3098
3099 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3100 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3101 double Br1 = dGammaR1-dGammaRTot1;
3102 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3103
3104 double mu;
3105
3106 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3107
3108 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3109
3110 return mu;
3111
3112 } else {
3113 //return myNPbase->muVHtautau(sqrt_s);
3114
3115 //VM: Just in case someone wants to add directly the production*decay
3116 //(which is the observable we fit at the end)
3117 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3118 if(NPmuVHtautau==1.0){
3119 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3120 } else {
3121 return NPmuVHtautau;
3122 }
3123 }
3124}
3125
3126muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3127: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3128{
3129 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3130 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3131}
3132
3134{
3135 if ((this->getModel()).isModelLinearized()) {
3136 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3137 } else {
3138 return myNPbase->muttHtautau(sqrt_s);
3139 }
3140}
3141
3142muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3143: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3144{
3145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3146 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3147}
3148
3150{
3151 //VM:Note that these values are valid for 13 TeV, they are not general
3152 //We should access the SM function that has all the values (for the
3153 //different energies). The values are slightly different, we should
3154 //check this.
3155 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3156 double xsSM_ttH = 0.499873;
3157 double xsSM_tH = 0.0821;
3158 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3159 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3160 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3161 //AG: Most general expression including quadratic corrections.
3162 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3163 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3164 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3165 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3166 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3167
3168 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3169 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3170 double Br1 = dGammaR1-dGammaRTot1;
3171 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3172
3173 double mu;
3174
3175 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3176
3177 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3178
3179 return mu;
3180
3181 } else {
3182
3183 //VM: Just in case someone wants to add directly the production*decay
3184 //(which is the observable we fit at the end)
3185 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3186 if(NPmuttHptH_Htautau==1.0){
3187 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3188 } else {
3189 return NPmuttHptH_Htautau;
3190 }
3191
3192 }
3193}
3194
3195muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3196: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3197{
3198 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3199 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3200}
3201
3203{
3204 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3205 //AG: Most general expression including quadratic corrections.
3206 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3207 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3208 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3209 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3210 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3211 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3212
3213 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3214 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3215 double Br1 = dGammaR1-dGammaRTot1;
3216 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3217
3218 double mu;
3219
3220 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3221
3222 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3223
3224 return mu;
3225
3226 } else {
3227
3228 //VM: Just in case someone wants to add directly the production*decay
3229 //(which is the observable we fit at the end)
3230 //Also, the bbH is missing here, I'll leave it as it was for the
3231 //moment (since bbH is really suppressed in the SM).
3232 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3233 if (NPmuggHpbbH_Htautau == 1.0){
3234 return (myNPbase->muggHtautau(sqrt_s));
3235 } else{
3236 return NPmuggHpbbH_Htautau;
3237 }
3238 }
3239}
3240
3241muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3242: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3243{
3244 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3245 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3246}
3247
3249{
3250 if ((this->getModel()).isModelLinearized()) {
3251 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3252 //AG: Most general expression including quadratic corrections.
3253 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3254 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3255 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3256 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3257 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3258
3259 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3260 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3261 double Br1 = dGammaR1-dGammaRTot1;
3262 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3263
3264 double mu;
3265
3266 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3267
3268 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3269
3270 return mu;
3271
3272 } else {
3273 return myNPbase->muggHbb(sqrt_s);
3274 }
3275}
3276
3277muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3278: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3279{
3280 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3281 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3282}
3283
3285{
3286 if ((this->getModel()).isModelLinearized()) {
3287 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3288 } else {
3289 return myNPbase->muVBFHbb(sqrt_s);
3290 }
3291}
3292
3293muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3294: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3295{
3296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3297 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3298}
3299
3301{
3302 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3303 //AG: Most general expression including quadratic corrections.
3304 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3305 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3306 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3307 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3308 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3309 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3310
3311 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3312 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3313 double Br1 = dGammaR1-dGammaRTot1;
3314 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3315
3316 double mu;
3317
3318 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3319
3320 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3321
3322 return mu;
3323
3324 } else {
3325 return myNPbase->muZHbb(sqrt_s);
3326 }
3327}
3328
3329muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3330: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3331{
3332 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3333 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3334}
3335
3337{
3338 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3339 //AG: Most general expression including quadratic corrections.
3340 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3341 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3342 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3343 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3344 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3345 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3346
3347 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3348 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3349 double Br1 = dGammaR1-dGammaRTot1;
3350 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3351
3352 double mu;
3353
3354 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3355
3356 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3357
3358 return mu;
3359
3360 } else {
3361 return myNPbase->muWHbb(sqrt_s);
3362 }
3363}
3364
3365muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3366: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3367{
3368 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3369 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3370}
3371
3373{
3374 if ((this->getModel()).isModelLinearized()) {
3375 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3376 } else {
3377 return myNPbase->muVHbb(sqrt_s);
3378 }
3379}
3380
3381muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3382: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3383{
3384 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3385 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3386}
3387
3389{
3390 if ((this->getModel()).isModelLinearized()) {
3391 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3392 } else {
3393 return myNPbase->muttHbb(sqrt_s);
3394 }
3395}
3396
3397muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3398: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3399{
3400 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3401 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3402}
3403
3405{
3406 //VM:Note that these values are valid for 13 TeV, they are not general
3407 //We should access the SM function that has all the values (for the
3408 //different energies). The values are slightly different, we should
3409 //check this.
3410 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3411 double xsSM_ttH = 0.499873;
3412 double xsSM_tH = 0.0821;
3413 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3414 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3415 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3416 //AG: Most general expression including quadratic corrections.
3417 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3418 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3419 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3420 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3421 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3422
3423 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3424 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3425 double Br1 = dGammaR1-dGammaRTot1;
3426 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3427
3428 double mu;
3429
3430 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3431
3432 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3433
3434 return mu;
3435
3436 } else {
3437
3438
3439 //VM: Just in case someone wants to add directly the production*decay
3440 //(which is the observable we fit at the end)
3441 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3442 if(NPmuttHptH_Hbb==1.0){
3443 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3444 } else {
3445 return NPmuttHptH_Hbb;
3446 }
3447 }
3448}
3449
3450muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3451: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3452{
3453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3454 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3455}
3456
3458{
3459 //VM:Note that these values are valid for 13 TeV, they are not general
3460 //We should access the SM function that has all the values (for the
3461 //different energies). The values are slightly different, we should
3462 //check this. Furthermore, the bbH is not included. In the SM this is
3463 //very suppressed (and it's probably also the case in the SMEFT) but
3464 //in some NP models it may not be the case.Unfortunately, bbH is not
3465 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3466 //SMEFT and add here the general expression.
3467 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3468 double xsSM_ggHbbH = 44.745;
3469 double xsSM_VBF = 3.49948;
3470 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3471 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3472 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3473 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3474 //AG: Most general expression including quadratic corrections.
3475 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3476 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3477 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3478 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3479 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3480
3481 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3482 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3483 double Br1 = dGammaR1-dGammaRTot1;
3484 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3485
3486 double mu;
3487
3488 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3489
3490 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3491
3492 return mu;
3493
3494 } else {
3495
3496
3497 //VM: Just in case someone wants to add directly the production*decay
3498 //(which is the observable we fit at the end). Furthermore, the Hbb
3499 //is not added in the original formula, fine for the SM (probably also
3500 //for the SMEFT) but not for all NP models.
3501 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3502 if(NPmuggHpVBFpbbH_Hbb==1.0){
3503 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3504 } else {
3505 return NPmuggHpVBFpbbH_Hbb;
3506 }
3507 }
3508}
3509
3510
3511
3512muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3513: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3514{
3515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3516 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3517}
3518
3520{
3521 if ((this->getModel()).isModelLinearized()) {
3522 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3523 } else {
3524 return myNPbase->muVHcc(sqrt_s);
3525 }
3526}
3527
3528
3529muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3530: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3531{
3532 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3533 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3534}
3535
3537{
3538
3539 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3540
3541}
3542
3543muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3544: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3545{
3546 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3547 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3548}
3549
3551{
3552
3553 if ((this->getModel()).isModelLinearized()) {
3554 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3555 } else {
3556 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3557 }
3558
3559}
3560
3561
3562muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3563: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3564{
3565 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3566 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3567}
3568
3570{
3571
3572 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3573
3574}
3575
3576muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3577: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3578{
3579 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3580 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3581}
3582
3584{
3585
3586 if ((this->getModel()).isModelLinearized()) {
3587 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3588 } else {
3589 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3590 }
3591
3592}
3593
3594
3595muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3596: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3597{
3598 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3599 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3600}
3601
3603{
3604 return myNPbase->muppHmumu(sqrt_s);
3605}
3606
3607muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3608: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3609{
3610 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3611 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3612}
3613
3615{
3616 return myNPbase->muppHZga(sqrt_s);
3617}
3618
3619muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3620: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3621{
3622 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3623 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3624}
3625
3627{
3628 if ((this->getModel()).isModelLinearized()) {
3629 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3630 } else {
3632 }
3633}
3634
3635muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3636: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3637{
3638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3639 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3640}
3641
3643{
3644 return (myNPbase->muttHZbbboost(sqrt_s));
3645}
3646
3647//AG:begin
3648ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3650{
3651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3652 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3653}
3655{
3656 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3657 if ((this->getModel()).isModelLinearized()) {
3658 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3659 } else {
3660 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3661 }
3662}
3663
3664
3665ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3666: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3667{
3668 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3669 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3670}
3672{
3673 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3674 if ((this->getModel()).isModelLinearized()) {
3675 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3676 } else {
3677 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3678 }
3679}
3680
3681
3682ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3683: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3684{
3685 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3686 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3687}
3689{
3690 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3691 if ((this->getModel()).isModelLinearized()) {
3692 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3693 } else {
3694 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3695 }
3696}
3697
3698
3699ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3700: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3701{
3702 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3703 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3704}
3706{
3707 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3708 if ((this->getModel()).isModelLinearized()) {
3709 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3710 } else {
3711 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3712 }
3713}
3714
3715
3716VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3717: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3718{
3719 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3720 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3721}
3723{
3724 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3725 if ((this->getModel()).isModelLinearized()) {
3726 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3727 } else {
3728 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3729 }
3730}
3731
3732
3733VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3734: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3735{
3736 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3737 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3738}
3740{
3741 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3742 if ((this->getModel()).isModelLinearized()) {
3743 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3744 } else {
3745 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3746 }
3747}
3748
3749
3750VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3751: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3752{
3753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3754 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3755}
3757{
3758 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3759 if ((this->getModel()).isModelLinearized()) {
3760 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3761 } else {
3762 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3763 }
3764}
3765
3766
3767VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3768: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3769{
3770 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3771 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3772}
3774{
3775 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3776 if ((this->getModel()).isModelLinearized()) {
3777 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3778 } else {
3779 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3780 }
3781}
3782
3783
3784WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3785: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3786{
3787 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3788 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3789}
3791{
3792 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3793 if ((this->getModel()).isModelLinearized()) {
3794 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3795 } else {
3796 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3797 }
3798}
3799
3800
3801WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3802: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3803{
3804 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3805 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3806}
3808{
3809 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3810 if ((this->getModel()).isModelLinearized()) {
3811 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3812 } else {
3813 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3814 }
3815}
3816
3817
3818WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3819: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3820{
3821 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3822 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3823}
3825{
3826 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3827 if ((this->getModel()).isModelLinearized()) {
3828 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3829 } else {
3830 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3831 }
3832}
3833
3834
3835WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3836: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3837{
3838 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3839 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3840}
3842{
3843 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3844 if ((this->getModel()).isModelLinearized()) {
3845 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3846 } else {
3847 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3848 }
3849}
3850
3851
3852ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3853: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3854{
3855 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3856 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3857}
3859{
3860 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3861 if ((this->getModel()).isModelLinearized()) {
3862 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3863 } else {
3864 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3865 }
3866}
3867
3868
3869ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3870: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3871{
3872 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3873 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3874}
3876{
3877 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3878 if ((this->getModel()).isModelLinearized()) {
3879 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3880 } else {
3881 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3882 }
3883}
3884
3885
3886ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3887: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3888{
3889 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3890 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3891}
3893{
3894 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3895 if ((this->getModel()).isModelLinearized()) {
3896 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3897 } else {
3898 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3899 }
3900}
3901
3902
3903ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3904: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3905{
3906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3907 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3908}
3910{
3911 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3912 if ((this->getModel()).isModelLinearized()) {
3913 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3914 } else {
3915 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3916 }
3917}
3918
3919
3920ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3921: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3922{
3923 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3924 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3925}
3927{
3928 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3929 if ((this->getModel()).isModelLinearized()) {
3930 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3931 } else {
3932 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3933 }
3934}
3935
3936
3937ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3938: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3939{
3940 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3941 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3942}
3944{
3945 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3946 if ((this->getModel()).isModelLinearized()) {
3947 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3948 } else {
3949 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3950 }
3951}
3952
3953
3954ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3956{
3957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3958 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
3959}
3961{
3962 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3963 if ((this->getModel()).isModelLinearized()) {
3964 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3965 } else {
3966 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
3967 }
3968}
3969
3970
3971ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3972: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3973{
3974 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3975 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
3976}
3978{
3979 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3980 if ((this->getModel()).isModelLinearized()) {
3981 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3982 } else {
3983 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
3984 }
3985}
3986
3987//AG:end
3988
3989UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3990{
3991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3992 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
3993}
3994
3996{
3998}
3999
4000UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4001{
4002 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4003 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4004}
4005
4007{
4009}
4010
4011UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4012{
4013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4014 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4015}
4016
4018{
4020}
4021
4022UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4023{
4024 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4025 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4026}
4027
4029{
4031}
4032
4034{
4035 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4036 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
4037}
4038
4040{
4041 return myNPbase->cgplusct();
4042}
4043
4045{
4046 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4047 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
4048}
4049
4051{
4052 return myNPbase->cgaplusct();
4053}
4054
4056{
4057 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4058 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
4059}
4060
4062{
4063 return myNPbase->cgminuscga();
4064}
4065
4067{
4068 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4069 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
4070}
4071\
4072
4073
4075{
4076 return myNPbase->cVpluscb();
4077}
4078
4080{
4081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4082 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
4083}
4084
4086{
4087 return myNPbase->cVplusctau();
4088}
4089
4091{
4092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4093 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
4094}
4095
4097{
4098 return myNPbase->cbminuscc();
4099}
4100
4102{
4103 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4104 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
4105}
4106
4108{
4109 return myNPbase->cbminusctau();
4110}
4111
4113{
4114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4115 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4116}
4117
4119{
4120 return myNPbase->ccminusctau();
4121}
4122
4123
4124// Full signal strengths at e+ e- colliders
4125// ----------------------------------------
4126
4127mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4128: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4129{
4130 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4131 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4132}
4133
4135{
4136 if ((this->getModel()).isModelLinearized()) {
4137 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4138 } else {
4140 }
4141}
4142
4143mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4144: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4145{
4146 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4147 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4148}
4149
4151{
4152 if ((this->getModel()).isModelLinearized()) {
4153 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4154 } else {
4156 }
4157}
4158
4159mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4160: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4161{
4162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4163 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4164}
4165
4167{
4168 if ((this->getModel()).isModelLinearized()) {
4169 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4170 } else {
4172 }
4173}
4174
4175mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4176: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4177{
4178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4179 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4180}
4181
4183{
4184 if ((this->getModel()).isModelLinearized()) {
4185 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4186 } else {
4188 }
4189}
4190
4191mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4192: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4193{
4194 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4195 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4196}
4197
4199{
4200 if ((this->getModel()).isModelLinearized()) {
4201 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4202 } else {
4204 }
4205}
4206
4207mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4208: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4209{
4210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4211 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4212}
4213
4215{
4216 if ((this->getModel()).isModelLinearized()) {
4217 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4218 } else {
4220 }
4221}
4222
4223mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4224: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4225{
4226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4227 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4228}
4229
4231{
4232 if ((this->getModel()).isModelLinearized()) {
4233 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4234 } else {
4236 }
4237}
4238
4239mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4240: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4241{
4242 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4243 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4244}
4245
4247{
4248 if ((this->getModel()).isModelLinearized()) {
4249 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4250 } else {
4252 }
4253}
4254
4255mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4256: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4257{
4258 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4259 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4260}
4261
4263{
4264 if ((this->getModel()).isModelLinearized()) {
4265 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4266 } else {
4268 }
4269}
4270
4271mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4272: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4273{
4274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4275 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4276}
4277
4279{
4280 if ((this->getModel()).isModelLinearized()) {
4281 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4282 } else {
4284 }
4285}
4286
4287mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4288: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4289{
4290 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4291 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4292}
4293
4295{
4296
4298
4299}
4300
4301mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4302: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4303{
4304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4305 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4306}
4307
4309{
4310
4311 if ((this->getModel()).isModelLinearized()) {
4312 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4313 } else {
4315 }
4316
4317}
4318
4319mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4320: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4321{
4322 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4323 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4324
4325}
4326
4328{
4329 if ((this->getModel()).isModelLinearized()) {
4330 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4331 } else {
4332 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4333 }
4334}
4335
4336mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4337: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4338{
4339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4340 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4341
4342}
4343
4345{
4346 if ((this->getModel()).isModelLinearized()) {
4347 return ((myNPbase->mueeWBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4348 } else {
4350 }
4351}
4352
4353mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4354: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4355{
4356 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4357 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4358
4359}
4360
4362{
4363 if ((this->getModel()).isModelLinearized()) {
4364 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4365 } else {
4366 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4367 }
4368}
4369
4370mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4372{
4373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4374 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4375
4376}
4377
4379{
4380 if ((this->getModel()).isModelLinearized()) {
4381 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4382 } else {
4383 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4384 }
4385}
4386
4387mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4389{
4390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4391 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4392
4393}
4394
4396{
4397 if ((this->getModel()).isModelLinearized()) {
4398 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4399 } else {
4400 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4401 }
4402}
4403
4404mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4405: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4406{
4407 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4408 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4409
4410}
4411
4413{
4414 if ((this->getModel()).isModelLinearized()) {
4415 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4416 } else {
4418 }
4419}
4420
4421mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4422: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4423{
4424 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4425 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4426
4427}
4428
4430{
4431 if ((this->getModel()).isModelLinearized()) {
4432 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4433 } else {
4434 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4435 }
4436}
4437
4438mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4439: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4440{
4441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4442 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4443
4444}
4445
4447{
4448 if ((this->getModel()).isModelLinearized()) {
4449 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4450 } else {
4451 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4452 }
4453}
4454
4455mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4456: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4457{
4458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4459 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4460
4461}
4462
4464{
4465 if ((this->getModel()).isModelLinearized()) {
4466 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4467 } else {
4469 }
4470}
4471
4472mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4473: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4474{
4475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4476 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4477
4478}
4479
4481{
4482 if ((this->getModel()).isModelLinearized()) {
4483 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4484 } else {
4486 }
4487}
4488
4489mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4491{
4492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4493 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4494
4495}
4496
4498{
4499 if ((this->getModel()).isModelLinearized()) {
4500 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4501 } else {
4502 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4503 }
4504}
4505
4506mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4507: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4508{
4509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4510 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4511
4512}
4513
4515{
4516 if ((this->getModel()).isModelLinearized()) {
4517 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4518 } else {
4520 }
4521}
4522
4523mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4524: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4525{
4526 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4527 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4528
4529}
4530
4532{
4533 if ((this->getModel()).isModelLinearized()) {
4534 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4535 } else {
4536 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4537 }
4538}
4539
4540mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4541: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4542{
4543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4544 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4545
4546}
4547
4549{
4550 if ((this->getModel()).isModelLinearized()) {
4551 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4552 } else {
4554 }
4555}
4556
4557
4558mueeHvvss::mueeHvvss(const StandardModel& SM_i, const double sqrt_s_i)
4559: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4560{
4561 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4562 throw std::runtime_error("mueeHvvss called with a class whose parent is not NPbase");
4563
4564}
4565
4567{
4568 if ((this->getModel()).isModelLinearized()) {
4569 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHssRatio()) - 1.0);
4570 } else {
4571 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHssRatio());
4572 }
4573}
4574
4575mueeHvvssPol::mueeHvvssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4576: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4577{
4578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4579 throw std::runtime_error("mueeHvvssPol called with a class whose parent is not NPbase");
4580
4581}
4582
4584{
4585 if ((this->getModel()).isModelLinearized()) {
4586 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4587 } else {
4589 }
4590}
4591
4592
4593mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4594: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4595{
4596 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4597 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4598
4599}
4600
4602{
4603 if ((this->getModel()).isModelLinearized()) {
4604 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4605 } else {
4606 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4607 }
4608}
4609
4610mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4611: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4612{
4613 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4614 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4615
4616}
4617
4619{
4620 if ((this->getModel()).isModelLinearized()) {
4621 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4622 } else {
4624 }
4625}
4626
4627mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4628: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4629{
4630 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4631 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4632
4633}
4634
4636{
4637 if ((this->getModel()).isModelLinearized()) {
4638 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4639 } else {
4640 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4641 }
4642}
4643
4644mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4645: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4646{
4647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4648 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4649
4650}
4651
4653{
4654 if ((this->getModel()).isModelLinearized()) {
4655 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4656 } else {
4658 }
4659}
4660
4661mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4662: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4663{
4664 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4665 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4666
4667}
4668
4670{
4671 if ((this->getModel()).isModelLinearized()) {
4672 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4673 } else {
4675 }
4676}
4677
4678mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4679: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4680{
4681 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4682 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4683
4684}
4685
4687{
4688 if ((this->getModel()).isModelLinearized()) {
4689 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4690 } else {
4692 }
4693}
4694
4695mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4696: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4697{
4698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4699 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4700
4701}
4702
4704{
4705 if ((this->getModel()).isModelLinearized()) {
4706 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4707 } else {
4708 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4709 }
4710}
4711
4712mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4713: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4714{
4715 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4716 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4717
4718}
4719
4721{
4722 if ((this->getModel()).isModelLinearized()) {
4723 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4724 } else {
4726 }
4727}
4728
4729mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4730: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4731{
4732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4733 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4734
4735}
4736
4738{
4739 if ((this->getModel()).isModelLinearized()) {
4740 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4741 } else {
4742 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4743 }
4744}
4745
4746mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4747: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4748{
4749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4750 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4751
4752}
4753
4755{
4756 if ((this->getModel()).isModelLinearized()) {
4757 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4758 } else {
4760 }
4761}
4762
4763mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4765{
4766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4767 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4768
4769}
4770
4772{
4773 if ((this->getModel()).isModelLinearized()) {
4774 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4775 } else {
4777 }
4778}
4779
4780mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4781: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4782{
4783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4784 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4785
4786}
4787
4789{
4790 if ((this->getModel()).isModelLinearized()) {
4791 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4792 } else {
4794 }
4795}
4796
4797mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4798: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4799{
4800 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4801 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4802
4803}
4804
4806{
4807 if ((this->getModel()).isModelLinearized()) {
4808 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4809 } else {
4811 }
4812}
4813
4814mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4815: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4816{
4817 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4818 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4819
4820}
4821
4823{
4824 if ((this->getModel()).isModelLinearized()) {
4825 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4826 } else {
4828 }
4829}
4830
4831mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4832: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4833{
4834 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4835 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4836}
4837
4839{
4840 if ((this->getModel()).isModelLinearized()) {
4841 return ((myNPbase->mueeZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4842 } else {
4843 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4844 }
4845}
4846
4847mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4848: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4849{
4850 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4851 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4852}
4853
4855{
4856 if ((this->getModel()).isModelLinearized()) {
4857 return ((myNPbase->mueeZBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4858 } else {
4860 }
4861}
4862
4863mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4864: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4865{
4866 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4867 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4868}
4869
4871{
4872 if ((this->getModel()).isModelLinearized()) {
4873 return ((myNPbase->mueettH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4874 } else {
4875 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4876 }
4877}
4878
4879mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4880: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4881{
4882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4883 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4884}
4885
4887{
4888 if ((this->getModel()).isModelLinearized()) {
4889 return ((myNPbase->mueettHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4890 } else {
4892 }
4893}
4894
4895
4896// Production signal strengths at mu+ mu- colliders
4897// ------------------------------------------------
4898
4899mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4900: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4901{
4902 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4903 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4904}
4905
4907{
4908 return myNPbase->mummZH(sqrt_s);
4909}
4910
4911
4912mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4913: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4914{
4915 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4916 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4917}
4918
4920{
4921 return myNPbase->mummHvv(sqrt_s);
4922}
4923
4924
4925mummHmm::mummHmm(const StandardModel& SM_i, const double sqrt_s_i)
4926: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4927{
4928 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4929 throw std::runtime_error("mummHmm called with a class whose parent is not NPbase");
4930}
4931
4933{
4934 return myNPbase->mummHmm(sqrt_s);
4935}
4936
4937
4938mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4939: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4940{
4941 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4942 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4943}
4944
4946{
4947 return myNPbase->mummttH(sqrt_s);
4948}
4949
4950
4951// Full signal strengths at mu+ mu- colliders
4952// -------------------------------------------
4953
4954
4955mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4956: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4957{
4958 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4959 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
4960}
4961
4963{
4964 if ((this->getModel()).isModelLinearized()) {
4965 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4966 } else {
4967 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
4968 }
4969}
4970
4971mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
4972: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4973{
4974 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4975 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4976}
4977
4979{
4980 if ((this->getModel()).isModelLinearized()) {
4981 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4982 } else {
4983 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
4984 }
4985}
4986
4987mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
4988: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4989{
4990 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4991 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
4992}
4993
4995{
4996 if ((this->getModel()).isModelLinearized()) {
4997 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4998 } else {
4999 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
5000 }
5001}
5002
5003mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
5004: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5005{
5006 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5007 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5008}
5009
5011{
5012 if ((this->getModel()).isModelLinearized()) {
5013 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5014 } else {
5015 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
5016 }
5017}
5018
5019mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5020: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5021{
5022 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5023 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
5024}
5025
5027{
5028 if ((this->getModel()).isModelLinearized()) {
5029 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5030 } else {
5032 }
5033}
5034
5035mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5036: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5037{
5038 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5039 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5040}
5041
5043{
5044 if ((this->getModel()).isModelLinearized()) {
5045 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5046 } else {
5047 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5048 }
5049}
5050
5051mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5052: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5053{
5054 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5055 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5056}
5057
5059{
5060 if ((this->getModel()).isModelLinearized()) {
5061 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5062 } else {
5063 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5064 }
5065}
5066
5067mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5068: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5069{
5070 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5071 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5072}
5073
5075{
5076 if ((this->getModel()).isModelLinearized()) {
5077 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5078 } else {
5079 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5080 }
5081}
5082
5083mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5084: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5085{
5086 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5087 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5088}
5089
5091{
5092 if ((this->getModel()).isModelLinearized()) {
5093 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5094 } else {
5095 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5096 }
5097}
5098
5099
5100
5101mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5102: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5103{
5104 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5105 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5106}
5107
5109{
5110 if ((this->getModel()).isModelLinearized()) {
5111 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5112 } else {
5113 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5114 }
5115}
5116
5117mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5118: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5119{
5120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5121 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5122}
5123
5125{
5126 if ((this->getModel()).isModelLinearized()) {
5127 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5128 } else {
5129 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5130 }
5131}
5132
5133mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5134: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5135{
5136 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5137 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5138}
5139
5141{
5142 if ((this->getModel()).isModelLinearized()) {
5143 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5144 } else {
5145 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5146 }
5147}
5148
5149mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5150: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5151{
5152 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5153 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5154}
5155
5157{
5158 if ((this->getModel()).isModelLinearized()) {
5159 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5160 } else {
5161 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5162 }
5163}
5164
5165mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5166: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5167{
5168 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5169 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5170}
5171
5173{
5174 if ((this->getModel()).isModelLinearized()) {
5175 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5176 } else {
5178 }
5179}
5180
5181mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5182: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5183{
5184 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5185 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5186}
5187
5189{
5190 if ((this->getModel()).isModelLinearized()) {
5191 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5192 } else {
5193 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5194 }
5195}
5196
5197mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5198: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5199{
5200 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5201 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5202}
5203
5205{
5206 if ((this->getModel()).isModelLinearized()) {
5207 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5208 } else {
5209 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5210 }
5211}
5212
5213mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5214: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5215{
5216 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5217 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5218}
5219
5221{
5222 if ((this->getModel()).isModelLinearized()) {
5223 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5224 } else {
5225 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5226 }
5227}
5228
5229mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5230: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5231{
5232 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5233 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5234}
5235
5237{
5238 if ((this->getModel()).isModelLinearized()) {
5239 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5240 } else {
5241 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5242 }
5243}
5244
5245
5246
5247mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5249{
5250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5251 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5252}
5253
5255{
5256 if ((this->getModel()).isModelLinearized()) {
5257 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5258 } else {
5259 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5260 }
5261}
5262
5263mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5264: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5265{
5266 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5267 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5268}
5269
5271{
5272 if ((this->getModel()).isModelLinearized()) {
5273 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5274 } else {
5275 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5276 }
5277}
5278
5279mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5280: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5281{
5282 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5283 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5284}
5285
5287{
5288 if ((this->getModel()).isModelLinearized()) {
5289 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5290 } else {
5291 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5292 }
5293}
5294
5295mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5296: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5297{
5298 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5299 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5300}
5301
5303{
5304 if ((this->getModel()).isModelLinearized()) {
5305 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5306 } else {
5307 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5308 }
5309}
5310
5311mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5312: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5313{
5314 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5315 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5316}
5317
5319{
5320 if ((this->getModel()).isModelLinearized()) {
5321 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5322 } else {
5324 }
5325}
5326
5327mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5328: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5329{
5330 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5331 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5332}
5333
5335{
5336 if ((this->getModel()).isModelLinearized()) {
5337 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5338 } else {
5339 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5340 }
5341}
5342
5343mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5344: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5345{
5346 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5347 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5348}
5349
5351{
5352 if ((this->getModel()).isModelLinearized()) {
5353 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5354 } else {
5355 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5356 }
5357}
5358
5359mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5360: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5361{
5362 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5363 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5364}
5365
5367{
5368 if ((this->getModel()).isModelLinearized()) {
5369 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5370 } else {
5372 }
5373}
5374
5375mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5376: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5377{
5378 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5379 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5380}
5381
5383{
5384 if ((this->getModel()).isModelLinearized()) {
5385 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5386 } else {
5388 }
5389}
5390
5391
5392
5393mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5394: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5395{
5396 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5397 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5398}
5399
5401{
5402 if ((this->getModel()).isModelLinearized()) {
5403 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5404 } else {
5405 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5406 }
5407}
5408
5409mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5410: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5411{
5412 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5413 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5414}
5415
5417{
5418 if ((this->getModel()).isModelLinearized()) {
5419 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5420 } else {
5421 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5422 }
5423}
5424
5425mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5426: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5427{
5428 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5429 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5430}
5431
5433{
5434 if ((this->getModel()).isModelLinearized()) {
5435 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5436 } else {
5437 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5438 }
5439}
5440
5441mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5442: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5443{
5444 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5445 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5446}
5447
5449{
5450 if ((this->getModel()).isModelLinearized()) {
5451 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5452 } else {
5453 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5454 }
5455}
5456
5457mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5458: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5459{
5460 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5461 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5462}
5463
5465{
5466 if ((this->getModel()).isModelLinearized()) {
5467 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5468 } else {
5470 }
5471}
5472
5473mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5474: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5475{
5476 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5477 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5478}
5479
5481{
5482 if ((this->getModel()).isModelLinearized()) {
5483 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5484 } else {
5485 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5486 }
5487}
5488
5489mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5491{
5492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5493 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5494}
5495
5497{
5498 if ((this->getModel()).isModelLinearized()) {
5499 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5500 } else {
5501 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5502 }
5503}
5504
5505mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5506: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5507{
5508 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5509 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5510}
5511
5513{
5514 if ((this->getModel()).isModelLinearized()) {
5515 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5516 } else {
5518 }
5519}
5520
5521mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5522: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5523{
5524 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5525 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5526}
5527
5529{
5530 if ((this->getModel()).isModelLinearized()) {
5531 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5532 } else {
5534 }
5535}
5536
5537
5538mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5539: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5540{
5541 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5542 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5543}
5544
5546{
5547 if ((this->getModel()).isModelLinearized()) {
5548 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5549 } else {
5550 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5551 }
5552}
5553
5554mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5555: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5556{
5557 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5558 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5559}
5560
5562{
5563 if ((this->getModel()).isModelLinearized()) {
5564 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5565 } else {
5566 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5567 }
5568}
5569
5570mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5571: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5572{
5573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5574 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5575}
5576
5578{
5579 if ((this->getModel()).isModelLinearized()) {
5580 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5581 } else {
5582 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5583 }
5584}
5585
5586mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5587: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5588{
5589 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5590 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5591}
5592
5594{
5595 if ((this->getModel()).isModelLinearized()) {
5596 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5597 } else {
5598 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5599 }
5600}
5601
5602mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5603: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5604{
5605 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5606 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5607}
5608
5610{
5611 if ((this->getModel()).isModelLinearized()) {
5612 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5613 } else {
5615 }
5616}
5617
5618mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5619: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5620{
5621 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5622 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5623}
5624
5626{
5627 if ((this->getModel()).isModelLinearized()) {
5628 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5629 } else {
5630 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5631 }
5632}
5633
5634mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5635: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5636{
5637 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5638 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5639}
5640
5642{
5643 if ((this->getModel()).isModelLinearized()) {
5644 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5645 } else {
5646 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5647 }
5648}
5649
5650mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5651: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5652{
5653 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5654 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5655}
5656
5658{
5659 if ((this->getModel()).isModelLinearized()) {
5660 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5661 } else {
5663 }
5664}
5665
5666mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5667: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5668{
5669 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5670 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5671}
5672
5674{
5675 if ((this->getModel()).isModelLinearized()) {
5676 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5677 } else {
5679 }
5680}
5681
5682
5683// The same in the narrow width approximation
5684
5685mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5686: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5687{
5688 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5689 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5690}
5691
5693{
5694 if ((this->getModel()).isModelLinearized()) {
5695 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5696 } else {
5697 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5698 }
5699}
5700
5701mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5702: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5703{
5704 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5705 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5706}
5707
5709{
5710 if ((this->getModel()).isModelLinearized()) {
5711 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5712 } else {
5713 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5714 }
5715}
5716
5717mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5718: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5719{
5720 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5721 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5722}
5723
5725{
5726 if ((this->getModel()).isModelLinearized()) {
5727 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5728 } else {
5729 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5730 }
5731}
5732
5733mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5734: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5735{
5736 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5737 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5738}
5739
5741{
5742 if ((this->getModel()).isModelLinearized()) {
5743 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5744 } else {
5745 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5746 }
5747}
5748
5749mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5750: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5751{
5752 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5753 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5754}
5755
5757{
5758 if ((this->getModel()).isModelLinearized()) {
5759 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5760 } else {
5762 }
5763}
5764
5765mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5766: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5767{
5768 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5769 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5770}
5771
5773{
5774 if ((this->getModel()).isModelLinearized()) {
5775 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5776 } else {
5777 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5778 }
5779}
5780
5781mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5782: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5783{
5784 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5785 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5786}
5787
5789{
5790 if ((this->getModel()).isModelLinearized()) {
5791 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5792 } else {
5794 }
5795}
5796
5797mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5798: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5799{
5800 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5801 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5802}
5803
5805{
5806 if ((this->getModel()).isModelLinearized()) {
5807 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5808 } else {
5810 }
5811}
5812
5813mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5814: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5815{
5816 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5817 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5818}
5819
5821{
5822 if ((this->getModel()).isModelLinearized()) {
5823 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5824 } else {
5826 }
5827}
5828
5829// Full signal strengths at ep colliders
5830// -------------------------------------
5831
5832muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5833: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5834{
5835 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5836 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5837
5838}
5839
5841{
5842 if ((this->getModel()).isModelLinearized()) {
5843 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5844 } else {
5845 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5846 }
5847}
5848
5849muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5850: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5851{
5852 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5853 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5854
5855}
5856
5858{
5859 if ((this->getModel()).isModelLinearized()) {
5860 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5861 } else {
5862 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5863 }
5864}
5865
5866muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5867: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5868{
5869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5870 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5871
5872}
5873
5875{
5876 if ((this->getModel()).isModelLinearized()) {
5877 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5878 } else {
5879 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5880 }
5881}
5882
5883muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5884: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5885{
5886 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5887 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5888
5889}
5890
5892{
5893 if ((this->getModel()).isModelLinearized()) {
5894 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5895 } else {
5897 }
5898}
5899
5900muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5901: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5902{
5903 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5904 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5905
5906}
5907
5909{
5910 if ((this->getModel()).isModelLinearized()) {
5911 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5912 } else {
5913 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5914 }
5915}
5916
5917muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5918: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5919{
5920 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5921 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5922
5923}
5924
5926{
5927 if ((this->getModel()).isModelLinearized()) {
5928 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5929 } else {
5931 }
5932}
5933
5934muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5935: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5936{
5937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5938 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5939
5940}
5941
5943{
5944 if ((this->getModel()).isModelLinearized()) {
5945 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5946 } else {
5948 }
5949}
5950
5951muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5952: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5953{
5954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5955 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5956
5957}
5958
5960{
5961 if ((this->getModel()).isModelLinearized()) {
5962 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5963 } else {
5964 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5965 }
5966}
5967
5968muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5970{
5971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5972 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
5973
5974}
5975
5977{
5978 if ((this->getModel()).isModelLinearized()) {
5979 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5980 } else {
5981 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
5982 }
5983}
5984
5985muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5986: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5987{
5988 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5989 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
5990
5991}
5992
5994{
5995 if ((this->getModel()).isModelLinearized()) {
5996 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5997 } else {
5998 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
5999 }
6000}
6001
6002muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6004{
6005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6006 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
6007
6008}
6009
6011{
6012 if ((this->getModel()).isModelLinearized()) {
6013 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6014 } else {
6016 }
6017}
6018
6019muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6020: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6021{
6022 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6023 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
6024
6025}
6026
6028{
6029 if ((this->getModel()).isModelLinearized()) {
6030 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6031 } else {
6032 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
6033 }
6034}
6035
6036muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6037: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6038{
6039 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6040 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6041
6042}
6043
6045{
6046 if ((this->getModel()).isModelLinearized()) {
6047 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6048 } else {
6050 }
6051}
6052
6053muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6054: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6055{
6056 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6057 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6058
6059}
6060
6062{
6063 if ((this->getModel()).isModelLinearized()) {
6064 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6065 } else {
6067 }
6068}
6069
6070
6071// -----------------------------------------------------------------------------
6072// STXS bins
6073// -----------------------------------------------------------------------------
6074
6075// -----------------------------------------------------------------------------
6076// Stage 0
6077// -----------------------------------------------------------------------------
6078
6079STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6080: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6081{
6082 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6083 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6084
6085}
6086
6088{
6089 return myNPbase->STXS0_qqH(sqrt_s);
6090}
6091
6092
6093// -----------------------------------------------------------------------------
6094// Stage 1
6095// -----------------------------------------------------------------------------
6096
6098: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6099{
6100 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6101 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6102
6103}
6104
6106{
6107 if ((this->getModel()).isModelLinearized()) {
6108 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6109 } else {
6111 }
6112}
6113
6114
6116: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6117{
6118 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6119 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6120
6121}
6122
6124{
6125 if ((this->getModel()).isModelLinearized()) {
6126 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6127 } else {
6129 }
6130}
6131
6132
6133STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6134: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6135{
6136 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6137 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6138
6139}
6140
6142{
6143 if ((this->getModel()).isModelLinearized()) {
6144 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6145 } else {
6147 }
6148}
6149
6151: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6152{
6153 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6154 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6155
6156}
6157
6159{
6160 if ((this->getModel()).isModelLinearized()) {
6161 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6162 } else {
6164 }
6165}
6166
6168: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6169{
6170 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6171 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6172
6173}
6174
6176{
6177 if ((this->getModel()).isModelLinearized()) {
6178 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6179 } else {
6181 }
6182}
6183
6185: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6186{
6187 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6188 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6189
6190}
6191
6193{
6194 if ((this->getModel()).isModelLinearized()) {
6195 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6196 } else {
6198 }
6199}
6200
6202: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6203{
6204 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6205 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6206
6207}
6208
6210{
6211 if ((this->getModel()).isModelLinearized()) {
6212 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6213 } else {
6215 }
6216}
6217
6219: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6220{
6221 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6222 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6223
6224}
6225
6227{
6228 if ((this->getModel()).isModelLinearized()) {
6229 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6230 } else {
6232 }
6233}
6234
6235
6237: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6238{
6239 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6240 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6241
6242}
6243
6245{
6246 if ((this->getModel()).isModelLinearized()) {
6247 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6248 } else {
6250 }
6251}
6252
6253
6255: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6256{
6257 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6258 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6259
6260}
6261
6263{
6264 if ((this->getModel()).isModelLinearized()) {
6265 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6266 } else {
6268 }
6269}
6270
6271
6273: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6274{
6275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6276 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6277
6278}
6279
6281{
6282 if ((this->getModel()).isModelLinearized()) {
6283 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6284 } else {
6286 }
6287}
6288
6289
6291: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6292{
6293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6294 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6295
6296}
6297
6299{
6300 if ((this->getModel()).isModelLinearized()) {
6301 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6302 } else {
6304 }
6305}
6306
6307
6309: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6310{
6311 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6312 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6313
6314}
6315
6317{
6318 if ((this->getModel()).isModelLinearized()) {
6319 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6320 } else {
6322 }
6323}
6324
6325
6327: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6328{
6329 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6330 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6331
6332}
6333
6335{
6336 if ((this->getModel()).isModelLinearized()) {
6337 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6338 } else {
6340 }
6341}
6342
6343
6344
6346: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6347{
6348 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6349 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6350
6351}
6352
6354{
6355 if ((this->getModel()).isModelLinearized()) {
6356 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6357 } else {
6359 }
6360}
6361
6362
6363
6365: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6366{
6367 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6368 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6369
6370}
6371
6373{
6374 if ((this->getModel()).isModelLinearized()) {
6375 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6376 } else {
6378 }
6379}
6380
6381
6382
6384: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6385{
6386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6387 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6388
6389}
6390
6392{
6393 if ((this->getModel()).isModelLinearized()) {
6394 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6395 } else {
6397 }
6398}
6399
6400
6401STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6402: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6403{
6404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6405 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6406
6407}
6408
6410{
6411 if ((this->getModel()).isModelLinearized()) {
6412 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6413 } else {
6415 }
6416}
6417
6418
6420: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6421{
6422 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6423 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6424
6425}
6426
6428{
6429 if ((this->getModel()).isModelLinearized()) {
6430 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6431 } else {
6433 }
6434}
6435
6437: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6438{
6439 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6440 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6441
6442}
6443
6445{
6446 if ((this->getModel()).isModelLinearized()) {
6447 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6448 } else {
6450 }
6451}
6452
6453
6455: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6456{
6457 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6458 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6459
6460}
6461
6463{
6464 if ((this->getModel()).isModelLinearized()) {
6465 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6466 } else {
6468 }
6469}
6470
6471
6472
6474: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6475{
6476 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6477 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6478
6479}
6480
6482{
6483 if ((this->getModel()).isModelLinearized()) {
6485 } else {
6487 }
6488}
6489
6490
6491
6493: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6494{
6495 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6496 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6497
6498}
6499
6501{
6502 if ((this->getModel()).isModelLinearized()) {
6504 } else {
6506 }
6507}
6508
6509
6511: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6512{
6513 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6514 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6515
6516}
6517
6519{
6520 if ((this->getModel()).isModelLinearized()) {
6521 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6522 } else {
6524 }
6525}
6526
6528: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6529{
6530 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6531 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6532
6533}
6534
6536{
6537 if ((this->getModel()).isModelLinearized()) {
6538 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6539 } else {
6541 }
6542}
6543
6545: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6546{
6547 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6548 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6549
6550}
6551
6553{
6554 if ((this->getModel()).isModelLinearized()) {
6555 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6556 } else {
6558 }
6559}
6560
6561
6563: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6564{
6565 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6566 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6567
6568}
6569
6571{
6572 if ((this->getModel()).isModelLinearized()) {
6574 } else {
6576 }
6577}
6578
6579
6581: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6582{
6583 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6584 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6585
6586}
6587
6589{
6590 if ((this->getModel()).isModelLinearized()) {
6592 } else {
6594 }
6595}
6596
6597
6599: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6600{
6601 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6602 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6603
6604}
6605
6607{
6608 if ((this->getModel()).isModelLinearized()) {
6609 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6610 } else {
6612 }
6613}
6614
6615STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6616: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6617{
6618 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6619 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6620
6621}
6622
6624{
6625 if ((this->getModel()).isModelLinearized()) {
6626 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6627 } else {
6629 }
6630}
6631
6632
6634: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6635{
6636 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6637 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6638
6639}
6640
6642{
6643 if ((this->getModel()).isModelLinearized()) {
6644 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6645 } else {
6647 }
6648}
6649
6650
6652: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6653{
6654 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6655 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6656
6657}
6658
6660{
6661 if ((this->getModel()).isModelLinearized()) {
6662 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6663 } else {
6665 }
6666}
6667
6668
6669
6671: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6672{
6673 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6674 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6675
6676}
6677
6679{
6680 if ((this->getModel()).isModelLinearized()) {
6682 } else {
6684 }
6685}
6686
6687
6688
6690: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6691{
6692 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6693 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6694
6695}
6696
6698{
6699 if ((this->getModel()).isModelLinearized()) {
6701 } else {
6703 }
6704}
6705
6706
6708: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6709{
6710 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6711 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6712
6713}
6714
6716{
6717 if ((this->getModel()).isModelLinearized()) {
6718 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6719 } else {
6721 }
6722}
6723
6725: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6726{
6727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6728 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6729
6730}
6731
6733{
6734 if ((this->getModel()).isModelLinearized()) {
6735 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6736 } else {
6738 }
6739}
6740
6742: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6743{
6744 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6745 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6746
6747}
6748
6750{
6751 if ((this->getModel()).isModelLinearized()) {
6752 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6753 } else {
6755 }
6756}
6757
6758
6760: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6761{
6762 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6763 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6764
6765}
6766
6768{
6769 if ((this->getModel()).isModelLinearized()) {
6771 } else {
6773 }
6774}
6775
6776
6778: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6779{
6780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6781 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6782
6783}
6784
6786{
6787 if ((this->getModel()).isModelLinearized()) {
6789 } else {
6791 }
6792}
6793
6794
6796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6797{
6798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6799 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6800
6801}
6802
6804{
6805 if ((this->getModel()).isModelLinearized()) {
6806 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6807 } else {
6809 }
6810}
6811
6812
6814: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6815{
6816 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6817 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6818
6819}
6820
6822{
6823 if ((this->getModel()).isModelLinearized()) {
6825 } else {
6827 }
6828}
6829
6830
6832: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6833{
6834 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6835 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6836
6837}
6838
6840{
6841 if ((this->getModel()).isModelLinearized()) {
6842 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6843 } else {
6845 }
6846}
6847
6848
6850: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6851{
6852 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6853 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6854
6855}
6856
6858{
6859 if ((this->getModel()).isModelLinearized()) {
6860 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6861 } else {
6863 }
6864}
6865
6866
6868: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6869{
6870 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6871 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6872
6873}
6874
6876{
6877 if ((this->getModel()).isModelLinearized()) {
6878 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6879 } else {
6881 }
6882}
6883
6884
6886: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6887{
6888 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6889 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6890
6891}
6892
6894{
6895 if ((this->getModel()).isModelLinearized()) {
6896 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6897 } else {
6899 }
6900}
6901
6902
6904: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6905{
6906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6907 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6908
6909}
6910
6912{
6913 if ((this->getModel()).isModelLinearized()) {
6915 } else {
6917 }
6918}
6919
6920
6922: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6923{
6924 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6925 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6926
6927}
6928
6930{
6931 if ((this->getModel()).isModelLinearized()) {
6932 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6933 } else {
6935 }
6936}
6937
6938
6940: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6941{
6942 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6943 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6944
6945}
6946
6948{
6949 if ((this->getModel()).isModelLinearized()) {
6950 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6951 } else {
6953 }
6954}
6955
6956
6958: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6959{
6960 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6961 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6962
6963}
6964
6966{
6967 if ((this->getModel()).isModelLinearized()) {
6968 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6969 } else {
6971 }
6972}
6973
6974
6976: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6977{
6978 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6979 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6980
6981}
6982
6984{
6985 if ((this->getModel()).isModelLinearized()) {
6986 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6987 } else {
6989 }
6990}
6991
6992
6993
6994// -----------------------------------------------------------------------------
6995// Stage 1.2
6996// -----------------------------------------------------------------------------
6997
6998STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6999: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7000{
7001 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7002 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7003
7004}
7005
7007{
7008 double BrHXXRatio = 1.0;
7009 if (fstate == 1){
7010 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7011 } else if (fstate == 2){
7012 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7013 } else if (fstate == 3){
7014 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7015 } else if (fstate == 4){
7016 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7017 } else {
7018 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7019 }
7020
7021 if ((this->getModel()).isModelLinearized()) {
7022 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7023 } else {
7024 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
7025 }
7026}
7027
7028// -----------------------------------------------------------------------------
7029
7030STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7031: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7032{
7033 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7034 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7035
7036}
7037
7039{
7040 double BrHXXRatio = 1.0;
7041 if (fstate == 1){
7042 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7043 } else if (fstate == 2){
7044 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7045 } else if (fstate == 3){
7046 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7047 } else if (fstate == 4){
7048 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7049 } else {
7050 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7051 }
7052
7053 if ((this->getModel()).isModelLinearized()) {
7054 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7055 } else {
7056 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7057 }
7058}
7059
7060// -----------------------------------------------------------------------------
7061
7062STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7063: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7064{
7065 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7066 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7067
7068}
7069
7071{
7072 double BrHXXRatio = 1.0;
7073 if (fstate == 1){
7074 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7075 } else if (fstate == 2){
7076 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7077 } else if (fstate == 3){
7078 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7079 } else if (fstate == 4){
7080 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7081 } else {
7082 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7083 }
7084
7085 if ((this->getModel()).isModelLinearized()) {
7086 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7087 } else {
7088 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7089 }
7090}
7091
7092// -----------------------------------------------------------------------------
7093
7094STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7095: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7096{
7097 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7098 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7099
7100}
7101
7103{
7104 double BrHXXRatio = 1.0;
7105 if (fstate == 1){
7106 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7107 } else if (fstate == 2){
7108 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7109 } else if (fstate == 3){
7110 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7111 } else if (fstate == 4){
7112 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7113 } else {
7114 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7115 }
7116
7117 if ((this->getModel()).isModelLinearized()) {
7118 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7119 } else {
7120 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7121 }
7122}
7123
7124
7125// -----------------------------------------------------------------------------
7126
7127STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7128: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7129{
7130 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7131 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7132
7133}
7134
7136{
7137 //-- Production:
7138 double weight = 1.0; //If normalized to the SM
7139
7140 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7141 double muProd1 = muProd -1.0;
7142 double muProd2 = 0.0;
7143 //-- Decay:
7144 double BrHXXRatio = 1.0;
7145 double dBrHXXRatio1 = 0.0;
7146 double dBrHXXRatio2 = 0.0;
7147
7148 if (fstate == 1){
7149 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7150 dBrHXXRatio1 = BrHXXRatio - 1.0;
7151 dBrHXXRatio2 = 0.0;
7152 } else if (fstate == 2){
7153 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7154 dBrHXXRatio1 = BrHXXRatio - 1.0;
7155 dBrHXXRatio2 = 0.0;
7156 } else if (fstate == 3){
7157 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7158 dBrHXXRatio1 = BrHXXRatio - 1.0;
7159 dBrHXXRatio2 = 0.0;
7160 } else if (fstate == 4){
7161 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7162 dBrHXXRatio1 = BrHXXRatio - 1.0;
7163 dBrHXXRatio2 = 0.0;
7164 } else {
7165 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7166 }
7167
7168 //-- Production x Decay:
7169 if ((this->getModel()).isModelLinearized()){
7170 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7171 } else if((this->getModel()).isModelNPquadratic()){
7172 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7173 } else {
7174 return weight*(muProd)*(BrHXXRatio);
7175 }
7176}
7177
7178
7179
7180
7181
7182// -----------------------------------------------------------------------------
7183
7184//VM:STXS2024;
7185STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7186: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7187{
7188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7189 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7190
7191}
7192
7194{
7195 //-- Production:
7196 double weight = 1.0; //If normalized to the SM
7197 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7198 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7199 double muProd1 = muProd -1.0;
7200 double muProd2 = 0.0;
7201
7202 //-- Decay:
7203 double BrHXXRatio = 1.0;
7204 double dBrHXXRatio1 = 0.0;
7205 double dBrHXXRatio2 = 0.0;
7206 if (fstate==0){
7207 // Use for Cross-section [pb] with no Higgs-boson decay
7208 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7209 } else if (fstate == 1){
7210 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7211 dBrHXXRatio1 = BrHXXRatio - 1.0;
7212 dBrHXXRatio2 = 0.0;
7213 } else if (fstate == 2){
7214 BrHXXRatio = (myNPbase->BrHgagaRatio());
7215 dBrHXXRatio1 = BrHXXRatio - 1.0;
7216 dBrHXXRatio2 = 0.0;
7217 } else if (fstate == 3){
7218 BrHXXRatio = (myNPbase->BrHbbRatio());
7219 dBrHXXRatio1 = BrHXXRatio - 1.0;
7220 dBrHXXRatio2 = 0.0;
7221 } else if (fstate == 4){
7222 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7223 dBrHXXRatio1 = BrHXXRatio - 1.0;
7224 dBrHXXRatio2 = 0.0;
7225 } else if (fstate == 5){
7226 BrHXXRatio = (myNPbase->BrHtautauRatio());
7227 dBrHXXRatio1 = BrHXXRatio - 1.0;
7228 dBrHXXRatio2 = 0.0;
7229 } else if (fstate == 6){
7230 BrHXXRatio = (myNPbase->BrHWWRatio());
7231 dBrHXXRatio1 = BrHXXRatio - 1.0;
7232 dBrHXXRatio2 = 0.0;
7233 } else if (fstate == 7){
7234 BrHXXRatio = (myNPbase->BrHZZRatio());
7235 dBrHXXRatio1 = BrHXXRatio - 1.0;
7236 dBrHXXRatio2 = 0.0;
7237 } else {
7238 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7239 }
7240
7241 //-- Production x Decay:
7242 if ((this->getModel()).isModelLinearized()){
7243 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7244 } else if((this->getModel()).isModelNPquadratic()){
7245 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7246 } else {
7247 return weight*(muProd)*(BrHXXRatio);
7248 }
7249
7250}
7251
7252
7253
7254// -----------------------------------------------------------------------------
7255
7256//VM:STXS2024;
7257STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7258: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7259{
7260 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7261 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7262
7263}
7264
7266{
7267 //-- Production:
7268 double weight = 1.0; //If normalized to the SM
7269 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7270 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7271 double muProd1 = muProd -1.0;
7272 double muProd2 = 0.0;
7273
7274 //-- Decay:
7275 double BrHXXRatio = 1.0;
7276 double dBrHXXRatio1 = 0.0;
7277 double dBrHXXRatio2 = 0.0;
7278 if (fstate==0){
7279 // Use for Cross-section [pb] with no Higgs-boson decay
7280 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7281 } else if (fstate == 1){
7282 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7283 dBrHXXRatio1 = BrHXXRatio - 1.0;
7284 dBrHXXRatio2 = 0.0;
7285 } else if (fstate == 2){
7286 BrHXXRatio = (myNPbase->BrHgagaRatio());
7287 dBrHXXRatio1 = BrHXXRatio - 1.0;
7288 dBrHXXRatio2 = 0.0;
7289 } else if (fstate == 3){
7290 BrHXXRatio = (myNPbase->BrHbbRatio());
7291 dBrHXXRatio1 = BrHXXRatio - 1.0;
7292 dBrHXXRatio2 = 0.0;
7293 } else if (fstate == 4){
7294 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7295 dBrHXXRatio1 = BrHXXRatio - 1.0;
7296 dBrHXXRatio2 = 0.0;
7297 } else if (fstate == 5){
7298 BrHXXRatio = (myNPbase->BrHtautauRatio());
7299 dBrHXXRatio1 = BrHXXRatio - 1.0;
7300 dBrHXXRatio2 = 0.0;
7301 } else if (fstate == 6){
7302 BrHXXRatio = (myNPbase->BrHWWRatio());
7303 dBrHXXRatio1 = BrHXXRatio - 1.0;
7304 dBrHXXRatio2 = 0.0;
7305 } else if (fstate == 7){
7306 BrHXXRatio = (myNPbase->BrHZZRatio());
7307 dBrHXXRatio1 = BrHXXRatio - 1.0;
7308 dBrHXXRatio2 = 0.0;
7309 } else {
7310 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7311 }
7312
7313 //-- Production x Decay:
7314 if ((this->getModel()).isModelLinearized()){
7315 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7316 } else if((this->getModel()).isModelNPquadratic()){
7317 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7318 } else {
7319 return weight*(muProd)*(BrHXXRatio);
7320 }
7321
7322}
7323
7324
7325
7326
7327// -----------------------------------------------------------------------------
7328
7329//VM:STXS2024;
7330STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7331: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7332{
7333 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7334 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7335
7336}
7337
7339{
7340 //-- Production:
7341 double weight = 1.0; //If normalized to the SM
7342 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7343 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7345 /(6.6369 + 20.642);
7346 double muProd1 = muProd -1.0;
7347 double muProd2 = 0.0;
7348
7349 //-- Decay:
7350 double BrHXXRatio = 1.0;
7351 double dBrHXXRatio1 = 0.0;
7352 double dBrHXXRatio2 = 0.0;
7353 if (fstate==0){
7354 // Use for Cross-section [pb] with no Higgs-boson decay
7355 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7356 } else if (fstate == 1){
7357 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7358 dBrHXXRatio1 = BrHXXRatio - 1.0;
7359 dBrHXXRatio2 = 0.0;
7360 } else if (fstate == 2){
7361 BrHXXRatio = (myNPbase->BrHgagaRatio());
7362 dBrHXXRatio1 = BrHXXRatio - 1.0;
7363 dBrHXXRatio2 = 0.0;
7364 } else if (fstate == 3){
7365 BrHXXRatio = (myNPbase->BrHbbRatio());
7366 dBrHXXRatio1 = BrHXXRatio - 1.0;
7367 dBrHXXRatio2 = 0.0;
7368 } else if (fstate == 4){
7369 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7370 dBrHXXRatio1 = BrHXXRatio - 1.0;
7371 dBrHXXRatio2 = 0.0;
7372 } else if (fstate == 5){
7373 BrHXXRatio = (myNPbase->BrHtautauRatio());
7374 dBrHXXRatio1 = BrHXXRatio - 1.0;
7375 dBrHXXRatio2 = 0.0;
7376 } else if (fstate == 6){
7377 BrHXXRatio = (myNPbase->BrHWWRatio());
7378 dBrHXXRatio1 = BrHXXRatio - 1.0;
7379 dBrHXXRatio2 = 0.0;
7380 } else if (fstate == 7){
7381 BrHXXRatio = (myNPbase->BrHZZRatio());
7382 dBrHXXRatio1 = BrHXXRatio - 1.0;
7383 dBrHXXRatio2 = 0.0;
7384 } else {
7385 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7386 }
7387
7388 //-- Production x Decay:
7389 if ((this->getModel()).isModelLinearized()){
7390 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7391 } else if((this->getModel()).isModelNPquadratic()){
7392 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7393 } else {
7394 return weight*(muProd)*(BrHXXRatio);
7395 }
7396
7397}
7398
7399
7400
7401
7402// -----------------------------------------------------------------------------
7403
7404//VM:STXS2024;
7405STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7406: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7407{
7408 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7409 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7410
7411}
7412
7414{
7415 //-- Production:
7416 double weight = 1.0; //If normalized to the SM
7417 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7418
7419 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7420 double muProd1 = muProd -1.0;
7421 double muProd2 = 0.0;
7422
7423 //-- Decay:
7424 double BrHXXRatio = 1.0;
7425 double dBrHXXRatio1 = 0.0;
7426 double dBrHXXRatio2 = 0.0;
7427 if (fstate==0){
7428 // Use for Cross-section [pb] with no Higgs-boson decay
7429 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7430 } else if (fstate == 1){
7431 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7432 dBrHXXRatio1 = BrHXXRatio - 1.0;
7433 dBrHXXRatio2 = 0.0;
7434 } else if (fstate == 2){
7435 BrHXXRatio = (myNPbase->BrHgagaRatio());
7436 dBrHXXRatio1 = BrHXXRatio - 1.0;
7437 dBrHXXRatio2 = 0.0;
7438 } else if (fstate == 3){
7439 BrHXXRatio = (myNPbase->BrHbbRatio());
7440 dBrHXXRatio1 = BrHXXRatio - 1.0;
7441 dBrHXXRatio2 = 0.0;
7442 } else if (fstate == 4){
7443 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7444 dBrHXXRatio1 = BrHXXRatio - 1.0;
7445 dBrHXXRatio2 = 0.0;
7446 } else if (fstate == 5){
7447 BrHXXRatio = (myNPbase->BrHtautauRatio());
7448 dBrHXXRatio1 = BrHXXRatio - 1.0;
7449 dBrHXXRatio2 = 0.0;
7450 } else if (fstate == 6){
7451 BrHXXRatio = (myNPbase->BrHWWRatio());
7452 dBrHXXRatio1 = BrHXXRatio - 1.0;
7453 dBrHXXRatio2 = 0.0;
7454 } else if (fstate == 7){
7455 BrHXXRatio = (myNPbase->BrHZZRatio());
7456 dBrHXXRatio1 = BrHXXRatio - 1.0;
7457 dBrHXXRatio2 = 0.0;
7458 } else {
7459 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7460 }
7461
7462 //-- Production x Decay:
7463 if ((this->getModel()).isModelLinearized()){
7464 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7465 } else if((this->getModel()).isModelNPquadratic()){
7466 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7467 } else {
7468 return weight*(muProd)*(BrHXXRatio);
7469 }
7470
7471}
7472
7473
7474
7475
7476
7477
7478
7479// -----------------------------------------------------------------------------
7480
7481//AG:STXS2024
7482STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7483: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7484{
7485 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7486 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7487
7488}
7489
7491{
7492 //-- Production:
7493 double weight = 1.0; //If normalized to the SM
7494 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7495 double muProd1 = muProd -1.0;
7496 double muProd2 = 0.0;
7497
7498 //-- Decay:
7499 double BrHXXRatio = 1.0;
7500 double dBrHXXRatio1 = 0.0;
7501 double dBrHXXRatio2 = 0.0;
7502 if (fstate==0){
7503 // Use for Cross-section [pb] with no Higgs-boson decay
7504 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7505 } else if (fstate == 1){
7506 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7507 dBrHXXRatio1 = BrHXXRatio - 1.0;
7508 dBrHXXRatio2 = 0.0;
7509 } else if (fstate == 2){
7510 BrHXXRatio = (myNPbase->BrHgagaRatio());
7511 dBrHXXRatio1 = BrHXXRatio - 1.0;
7512 dBrHXXRatio2 = 0.0;
7513 } else if (fstate == 3){
7514 BrHXXRatio = (myNPbase->BrHbbRatio());
7515 dBrHXXRatio1 = BrHXXRatio - 1.0;
7516 dBrHXXRatio2 = 0.0;
7517 } else if (fstate == 4){
7518 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7519 dBrHXXRatio1 = BrHXXRatio - 1.0;
7520 dBrHXXRatio2 = 0.0;
7521 } else if (fstate == 5){
7522 BrHXXRatio = (myNPbase->BrHtautauRatio());
7523 dBrHXXRatio1 = BrHXXRatio - 1.0;
7524 dBrHXXRatio2 = 0.0;
7525 } else if (fstate == 6){
7526 BrHXXRatio = (myNPbase->BrHWWRatio());
7527 dBrHXXRatio1 = BrHXXRatio - 1.0;
7528 dBrHXXRatio2 = 0.0;
7529 } else if (fstate == 7){
7530 BrHXXRatio = (myNPbase->BrHZZRatio());
7531 dBrHXXRatio1 = BrHXXRatio - 1.0;
7532 dBrHXXRatio2 = 0.0;
7533 } else {
7534 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7535 }
7536
7537 //-- Production x Decay:
7538 if ((this->getModel()).isModelLinearized()){
7539 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7540 } else if((this->getModel()).isModelNPquadratic()){
7541 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7542 } else {
7543 return weight*(muProd)*(BrHXXRatio);
7544 }
7545
7546}
7547
7548// -----------------------------------------------------------------------------
7549
7550//AG:STXS2024
7551STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7552: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7553{
7554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7555 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7556
7557}
7558
7560{
7561 //-- Production:
7562 double weight = 1.0; //If normalized to the SM
7563 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7564 double muProd1 = muProd -1.0;
7565 double muProd2 = 0.0;
7566
7567 //-- Decay:
7568 double BrHXXRatio = 1.0;
7569 double dBrHXXRatio1 = 0.0;
7570 double dBrHXXRatio2 = 0.0;
7571 if (fstate==0){
7572 // Use for Cross-section [pb] with no Higgs-boson decay
7573 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7574 } else if (fstate == 1){
7575 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7576 dBrHXXRatio1 = BrHXXRatio - 1.0;
7577 dBrHXXRatio2 = 0.0;
7578 } else if (fstate == 2){
7579 BrHXXRatio = (myNPbase->BrHgagaRatio());
7580 dBrHXXRatio1 = BrHXXRatio - 1.0;
7581 dBrHXXRatio2 = 0.0;
7582 } else if (fstate == 3){
7583 BrHXXRatio = (myNPbase->BrHbbRatio());
7584 dBrHXXRatio1 = BrHXXRatio - 1.0;
7585 dBrHXXRatio2 = 0.0;
7586 } else if (fstate == 4){
7587 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7588 dBrHXXRatio1 = BrHXXRatio - 1.0;
7589 dBrHXXRatio2 = 0.0;
7590 } else if (fstate == 5){
7591 BrHXXRatio = (myNPbase->BrHtautauRatio());
7592 dBrHXXRatio1 = BrHXXRatio - 1.0;
7593 dBrHXXRatio2 = 0.0;
7594 } else if (fstate == 6){
7595 BrHXXRatio = (myNPbase->BrHWWRatio());
7596 dBrHXXRatio1 = BrHXXRatio - 1.0;
7597 dBrHXXRatio2 = 0.0;
7598 } else if (fstate == 7){
7599 BrHXXRatio = (myNPbase->BrHZZRatio());
7600 dBrHXXRatio1 = BrHXXRatio - 1.0;
7601 dBrHXXRatio2 = 0.0;
7602 } else {
7603 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7604 }
7605
7606 //-- Production x Decay:
7607 if ((this->getModel()).isModelLinearized()){
7608 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7609 } else if((this->getModel()).isModelNPquadratic()){
7610 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7611 } else {
7612 return weight*(muProd)*(BrHXXRatio);
7613 }
7614
7615}
7616
7617// -----------------------------------------------------------------------------
7618
7619//AG:STXS2024
7620STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7621: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7622{
7623 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7624 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7625
7626}
7627
7629{
7630 //-- Production:
7631 double weight = 1.0; //If normalized to the SM
7632 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7633 double muProd1 = muProd -1.0;
7634 double muProd2 = 0.0;
7635
7636 //-- Decay:
7637 double BrHXXRatio = 1.0;
7638 double dBrHXXRatio1 = 0.0;
7639 double dBrHXXRatio2 = 0.0;
7640 if (fstate==0){
7641 // Use for Cross-section [pb] with no Higgs-boson decay
7642 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7643 } else if (fstate == 1){
7644 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7645 dBrHXXRatio1 = BrHXXRatio - 1.0;
7646 dBrHXXRatio2 = 0.0;
7647 } else if (fstate == 2){
7648 BrHXXRatio = (myNPbase->BrHgagaRatio());
7649 dBrHXXRatio1 = BrHXXRatio - 1.0;
7650 dBrHXXRatio2 = 0.0;
7651 } else if (fstate == 3){
7652 BrHXXRatio = (myNPbase->BrHbbRatio());
7653 dBrHXXRatio1 = BrHXXRatio - 1.0;
7654 dBrHXXRatio2 = 0.0;
7655 } else if (fstate == 4){
7656 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7657 dBrHXXRatio1 = BrHXXRatio - 1.0;
7658 dBrHXXRatio2 = 0.0;
7659 } else if (fstate == 5){
7660 BrHXXRatio = (myNPbase->BrHtautauRatio());
7661 dBrHXXRatio1 = BrHXXRatio - 1.0;
7662 dBrHXXRatio2 = 0.0;
7663 } else if (fstate == 6){
7664 BrHXXRatio = (myNPbase->BrHWWRatio());
7665 dBrHXXRatio1 = BrHXXRatio - 1.0;
7666 dBrHXXRatio2 = 0.0;
7667 } else if (fstate == 7){
7668 BrHXXRatio = (myNPbase->BrHZZRatio());
7669 dBrHXXRatio1 = BrHXXRatio - 1.0;
7670 dBrHXXRatio2 = 0.0;
7671 } else {
7672 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7673 }
7674
7675 //-- Production x Decay:
7676 if ((this->getModel()).isModelLinearized()){
7677 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7678 } else if((this->getModel()).isModelNPquadratic()){
7679 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7680 } else {
7681 return weight*(muProd)*(BrHXXRatio);
7682 }
7683
7684}
7685
7686// -----------------------------------------------------------------------------
7687
7688STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7689: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7690{
7691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7692 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7693
7694}
7695
7697{
7698 double BrHXXRatio = 1.0;
7699 if (fstate == 1){
7700 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7701 } else if (fstate == 2){
7702 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7703 } else if (fstate == 3){
7704 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7705 } else if (fstate == 4){
7706 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7707 } else {
7708 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7709 }
7710
7711 if ((this->getModel()).isModelLinearized()) {
7712 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7713 } else {
7714 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7715 }
7716}
7717
7718// -----------------------------------------------------------------------------
7719
7720STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7721: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7722{
7723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7724 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7725
7726}
7727
7729{
7730 double BrHXXRatio = 1.0;
7731 if (fstate == 1){
7732 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7733 } else if (fstate == 2){
7734 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7735 } else if (fstate == 3){
7736 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7737 } else if (fstate == 4){
7738 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7739 } else {
7740 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7741 }
7742
7743 if ((this->getModel()).isModelLinearized()) {
7744 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7745 } else {
7746 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7747 }
7748}
7749
7750
7751
7752
7753
7754// -----------------------------------------------------------------------------
7755
7756//VM:STXS2024;
7757STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7758: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7759{
7760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7761 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7762
7763}
7764
7766{
7767 //-- Production:
7768 double weight = 1.0; //If normalized to the SM
7769 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7770 //We should weight each xsection with the SM prediction. We need to check
7771 //this values, nevertheless, the difference between the two parametrisations
7772 //is extremely small (way beyond our current precision)
7773 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7775 /(2.);
7776 double muProd1 = muProd -1.0;
7777 double muProd2 = 0.0;
7778
7779 //-- Decay:
7780 double BrHXXRatio = 1.0;
7781 double dBrHXXRatio1 = 0.0;
7782 double dBrHXXRatio2 = 0.0;
7783 if (fstate==0){
7784 // Use for Cross-section [pb] with no Higgs-boson decay
7785 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7786 } else if (fstate == 1){
7787 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7788 dBrHXXRatio1 = BrHXXRatio - 1.0;
7789 dBrHXXRatio2 = 0.0;
7790 } else if (fstate == 2){
7791 BrHXXRatio = (myNPbase->BrHgagaRatio());
7792 dBrHXXRatio1 = BrHXXRatio - 1.0;
7793 dBrHXXRatio2 = 0.0;
7794 } else if (fstate == 3){
7795 BrHXXRatio = (myNPbase->BrHbbRatio());
7796 dBrHXXRatio1 = BrHXXRatio - 1.0;
7797 dBrHXXRatio2 = 0.0;
7798 } else if (fstate == 4){
7799 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7800 dBrHXXRatio1 = BrHXXRatio - 1.0;
7801 dBrHXXRatio2 = 0.0;
7802 } else if (fstate == 5){
7803 BrHXXRatio = (myNPbase->BrHtautauRatio());
7804 dBrHXXRatio1 = BrHXXRatio - 1.0;
7805 dBrHXXRatio2 = 0.0;
7806 } else if (fstate == 6){
7807 BrHXXRatio = (myNPbase->BrHWWRatio());
7808 dBrHXXRatio1 = BrHXXRatio - 1.0;
7809 dBrHXXRatio2 = 0.0;
7810 } else if (fstate == 7){
7811 BrHXXRatio = (myNPbase->BrHZZRatio());
7812 dBrHXXRatio1 = BrHXXRatio - 1.0;
7813 dBrHXXRatio2 = 0.0;
7814 } else {
7815 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7816 }
7817
7818 //-- Production x Decay:
7819 if ((this->getModel()).isModelLinearized()){
7820 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7821 } else if((this->getModel()).isModelNPquadratic()){
7822 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7823 } else {
7824 return weight*(muProd)*(BrHXXRatio);
7825 }
7826
7827}
7828
7829
7830
7831
7832// -----------------------------------------------------------------------------
7833
7834//AG:STXS2024
7835STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7836: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7837{
7838 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7839 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7840
7841}
7842
7844{
7845 //-- Production:
7846 double weight = 1.0; //If normalized to the SM
7848 double muProd1 = muProd -1.0;
7849 double muProd2 = 0.0;
7850
7851 //-- Decay:
7852 double BrHXXRatio = 1.0;
7853 double dBrHXXRatio1 = 0.0;
7854 double dBrHXXRatio2 = 0.0;
7855 if (fstate==0){
7856 // Use for Cross-section [pb] with no Higgs-boson decay
7857 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7858 } else if (fstate == 1){
7859 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7860 dBrHXXRatio1 = BrHXXRatio - 1.0;
7861 dBrHXXRatio2 = 0.0;
7862 } else if (fstate == 2){
7863 BrHXXRatio = (myNPbase->BrHgagaRatio());
7864 dBrHXXRatio1 = BrHXXRatio - 1.0;
7865 dBrHXXRatio2 = 0.0;
7866 } else if (fstate == 3){
7867 BrHXXRatio = (myNPbase->BrHbbRatio());
7868 dBrHXXRatio1 = BrHXXRatio - 1.0;
7869 dBrHXXRatio2 = 0.0;
7870 } else if (fstate == 4){
7871 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7872 dBrHXXRatio1 = BrHXXRatio - 1.0;
7873 dBrHXXRatio2 = 0.0;
7874 } else if (fstate == 5){
7875 BrHXXRatio = (myNPbase->BrHtautauRatio());
7876 dBrHXXRatio1 = BrHXXRatio - 1.0;
7877 dBrHXXRatio2 = 0.0;
7878 }else {
7879 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7880 }
7881
7882 //-- Production x Decay:
7883 if ((this->getModel()).isModelLinearized()){
7884 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7885 } else if((this->getModel()).isModelNPquadratic()){
7886 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7887 } else {
7888 return weight*(muProd)*(BrHXXRatio);
7889 }
7890
7891}
7892
7893
7894
7895
7896//VM:STXS2024;
7897STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7898: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7899{
7900 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7901 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7902
7903}
7904
7906{
7907 //-- Production:
7908 double weight = 1.0; //If normalized to the SM
7909 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7910 //We should weight each xsection with the SM prediction. We need to check
7911 //this values, nevertheless, the difference between the two parametrisations
7912 //is extremely small (way beyond our current precision)
7915 /(2.);
7916 double muProd1 = muProd -1.0;
7917 double muProd2 = 0.0;
7918
7919 //-- Decay:
7920 double BrHXXRatio = 1.0;
7921 double dBrHXXRatio1 = 0.0;
7922 double dBrHXXRatio2 = 0.0;
7923 if (fstate==0){
7924 // Use for Cross-section [pb] with no Higgs-boson decay
7925 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7926 } else if (fstate == 1){
7927 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7928 dBrHXXRatio1 = BrHXXRatio - 1.0;
7929 dBrHXXRatio2 = 0.0;
7930 } else if (fstate == 2){
7931 BrHXXRatio = (myNPbase->BrHgagaRatio());
7932 dBrHXXRatio1 = BrHXXRatio - 1.0;
7933 dBrHXXRatio2 = 0.0;
7934 } else if (fstate == 3){
7935 BrHXXRatio = (myNPbase->BrHbbRatio());
7936 dBrHXXRatio1 = BrHXXRatio - 1.0;
7937 dBrHXXRatio2 = 0.0;
7938 } else if (fstate == 4){
7939 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7940 dBrHXXRatio1 = BrHXXRatio - 1.0;
7941 dBrHXXRatio2 = 0.0;
7942 } else if (fstate == 5){
7943 BrHXXRatio = (myNPbase->BrHtautauRatio());
7944 dBrHXXRatio1 = BrHXXRatio - 1.0;
7945 dBrHXXRatio2 = 0.0;
7946 } else if (fstate == 6){
7947 BrHXXRatio = (myNPbase->BrHWWRatio());
7948 dBrHXXRatio1 = BrHXXRatio - 1.0;
7949 dBrHXXRatio2 = 0.0;
7950 } else if (fstate == 7){
7951 BrHXXRatio = (myNPbase->BrHZZRatio());
7952 dBrHXXRatio1 = BrHXXRatio - 1.0;
7953 dBrHXXRatio2 = 0.0;
7954 } else {
7955 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7956 }
7957
7958 //-- Production x Decay:
7959 if ((this->getModel()).isModelLinearized()){
7960 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7961 } else if((this->getModel()).isModelNPquadratic()){
7962 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7963 } else {
7964 return weight*(muProd)*(BrHXXRatio);
7965 }
7966
7967}
7968
7969
7970// -----------------------------------------------------------------------------
7971
7973: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7974{
7975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7976 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
7977
7978}
7979
7981{
7982 double BrHXXRatio = 1.0;
7983 if (fstate == 1){
7984 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7985 } else if (fstate == 2){
7986 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7987 } else if (fstate == 3){
7988 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7989 } else if (fstate == 4){
7990 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7991 } else {
7992 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
7993 }
7994
7995 if ((this->getModel()).isModelLinearized()) {
7996 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7997 } else {
7999 }
8000}
8001
8002// -----------------------------------------------------------------------------
8003
8005: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8006{
8007
8008 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8009 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8010
8011}
8012
8014{
8015 double BrHXXRatio = 1.0;
8016 if (fstate == 1){
8017 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8018 } else if (fstate == 2){
8019 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8020 } else if (fstate == 3){
8021 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8022 } else if (fstate == 4){
8023 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8024 } else {
8025 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8026 }
8027
8028 if ((this->getModel()).isModelLinearized()) {
8029 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8030 } else {
8032 }
8033}
8034
8035// -----------------------------------------------------------------------------
8036
8038: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8039{
8040 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8041 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8042
8043}
8044
8046{
8047 double BrHXXRatio = 1.0;
8048 if (fstate == 1){
8049 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8050 } else if (fstate == 2){
8051 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8052 } else if (fstate == 3){
8053 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8054 } else if (fstate == 4){
8055 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8056 } else {
8057 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8058 }
8059
8060 if ((this->getModel()).isModelLinearized()) {
8061 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8062 } else {
8064 }
8065}
8066
8067// -----------------------------------------------------------------------------
8068
8070: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8071{
8072 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8073 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8074
8075}
8076
8078{
8079 double BrHXXRatio = 1.0;
8080 if (fstate == 1){
8081 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8082 } else if (fstate == 2){
8083 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8084 } else if (fstate == 3){
8085 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8086 } else if (fstate == 4){
8087 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8088 } else {
8089 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8090 }
8091
8092 if ((this->getModel()).isModelLinearized()) {
8093 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8094 } else {
8096 }
8097}
8098
8099
8100
8101
8102
8103// -----------------------------------------------------------------------------
8104
8105//VM:STXS2024;
8106STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8107: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8108{
8109 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8110 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8111
8112}
8113
8115{
8116
8117
8118
8119 //-- Production:
8120 double weight = 1.0; //If normalized to the SM
8121 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8122 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8123 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8124 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8125 //The possible error that we could be introducing here is way below our precision!
8126 double muProd = (
8130 )/(2.9636+0.94321+0.87751);
8131 double muProd1 = muProd -1.0;
8132 double muProd2 = 0.0;
8133
8134 //-- Decay:
8135 double BrHXXRatio = 1.0;
8136 double dBrHXXRatio1 = 0.0;
8137 double dBrHXXRatio2 = 0.0;
8138 if (fstate==0){
8139 // Use for Cross-section [pb] with no Higgs-boson decay
8140 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8141 } else if (fstate == 1){
8142 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8143 dBrHXXRatio1 = BrHXXRatio - 1.0;
8144 dBrHXXRatio2 = 0.0;
8145 } else if (fstate == 2){
8146 BrHXXRatio = (myNPbase->BrHgagaRatio());
8147 dBrHXXRatio1 = BrHXXRatio - 1.0;
8148 dBrHXXRatio2 = 0.0;
8149 } else if (fstate == 3){
8150 BrHXXRatio = (myNPbase->BrHbbRatio());
8151 dBrHXXRatio1 = BrHXXRatio - 1.0;
8152 dBrHXXRatio2 = 0.0;
8153 } else if (fstate == 4){
8154 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8155 dBrHXXRatio1 = BrHXXRatio - 1.0;
8156 dBrHXXRatio2 = 0.0;
8157 } else if (fstate == 5){
8158 BrHXXRatio = (myNPbase->BrHtautauRatio());
8159 dBrHXXRatio1 = BrHXXRatio - 1.0;
8160 dBrHXXRatio2 = 0.0;
8161 } else if (fstate == 6){
8162 BrHXXRatio = (myNPbase->BrHWWRatio());
8163 dBrHXXRatio1 = BrHXXRatio - 1.0;
8164 dBrHXXRatio2 = 0.0;
8165 } else if (fstate == 7){
8166 BrHXXRatio = (myNPbase->BrHZZRatio());
8167 dBrHXXRatio1 = BrHXXRatio - 1.0;
8168 dBrHXXRatio2 = 0.0;
8169 } else {
8170 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8171 }
8172
8173 //-- Production x Decay:
8174 if ((this->getModel()).isModelLinearized()){
8175 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8176 } else if((this->getModel()).isModelNPquadratic()){
8177 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8178 } else {
8179 return weight*(muProd)*(BrHXXRatio);
8180 }
8181
8182}
8183
8184
8185
8186
8187
8188
8189
8190// -----------------------------------------------------------------------------
8191
8192
8193//VM:STXS2024;
8194STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8195: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8196{
8197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8198 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8199
8200}
8201
8203{
8204 //-- Production:
8205 double weight = 1.0; //If normalized to the SM
8206 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8207 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8210 /(0.45825 + 0.10632 + 0.017974);
8211 double muProd1 = muProd -1.0;
8212 double muProd2 = 0.0;
8213
8214 //-- Decay:
8215 double BrHXXRatio = 1.0;
8216 double dBrHXXRatio1 = 0.0;
8217 double dBrHXXRatio2 = 0.0;
8218 if (fstate==0){
8219 // Use for Cross-section [pb] with no Higgs-boson decay
8220 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8221 } else if (fstate == 1){
8222 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8223 dBrHXXRatio1 = BrHXXRatio - 1.0;
8224 dBrHXXRatio2 = 0.0;
8225 } else if (fstate == 2){
8226 BrHXXRatio = (myNPbase->BrHgagaRatio());
8227 dBrHXXRatio1 = BrHXXRatio - 1.0;
8228 dBrHXXRatio2 = 0.0;
8229 } else if (fstate == 3){
8230 BrHXXRatio = (myNPbase->BrHbbRatio());
8231 dBrHXXRatio1 = BrHXXRatio - 1.0;
8232 dBrHXXRatio2 = 0.0;
8233 } else if (fstate == 4){
8234 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8235 dBrHXXRatio1 = BrHXXRatio - 1.0;
8236 dBrHXXRatio2 = 0.0;
8237 } else if (fstate == 5){
8238 BrHXXRatio = (myNPbase->BrHtautauRatio());
8239 dBrHXXRatio1 = BrHXXRatio - 1.0;
8240 dBrHXXRatio2 = 0.0;
8241 } else if (fstate == 6){
8242 BrHXXRatio = (myNPbase->BrHWWRatio());
8243 dBrHXXRatio1 = BrHXXRatio - 1.0;
8244 dBrHXXRatio2 = 0.0;
8245 } else if (fstate == 7){
8246 BrHXXRatio = (myNPbase->BrHZZRatio());
8247 dBrHXXRatio1 = BrHXXRatio - 1.0;
8248 dBrHXXRatio2 = 0.0;
8249 } else {
8250 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8251 }
8252
8253 //-- Production x Decay:
8254 if ((this->getModel()).isModelLinearized()){
8255 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8256 } else if((this->getModel()).isModelNPquadratic()){
8257 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8258 } else {
8259 return weight*(muProd)*(BrHXXRatio);
8260 }
8261
8262}
8263
8264
8265
8266
8267// -----------------------------------------------------------------------------
8268
8269
8270//VM:STXS2024;
8271STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8272: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8273{
8274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8275 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8276
8277}
8278
8280{
8281 //-- Production:
8282 double weight = 1.0; //If normalized to the SM
8283 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8284 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8286 /(0.10632 + 0.017974);
8287 double muProd1 = muProd -1.0;
8288 double muProd2 = 0.0;
8289
8290 //-- Decay:
8291 double BrHXXRatio = 1.0;
8292 double dBrHXXRatio1 = 0.0;
8293 double dBrHXXRatio2 = 0.0;
8294 if (fstate==0){
8295 // Use for Cross-section [pb] with no Higgs-boson decay
8296 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8297 } else if (fstate == 1){
8298 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8299 dBrHXXRatio1 = BrHXXRatio - 1.0;
8300 dBrHXXRatio2 = 0.0;
8301 } else if (fstate == 2){
8302 BrHXXRatio = (myNPbase->BrHgagaRatio());
8303 dBrHXXRatio1 = BrHXXRatio - 1.0;
8304 dBrHXXRatio2 = 0.0;
8305 } else if (fstate == 3){
8306 BrHXXRatio = (myNPbase->BrHbbRatio());
8307 dBrHXXRatio1 = BrHXXRatio - 1.0;
8308 dBrHXXRatio2 = 0.0;
8309 } else if (fstate == 4){
8310 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8311 dBrHXXRatio1 = BrHXXRatio - 1.0;
8312 dBrHXXRatio2 = 0.0;
8313 } else if (fstate == 5){
8314 BrHXXRatio = (myNPbase->BrHtautauRatio());
8315 dBrHXXRatio1 = BrHXXRatio - 1.0;
8316 dBrHXXRatio2 = 0.0;
8317 } else if (fstate == 6){
8318 BrHXXRatio = (myNPbase->BrHWWRatio());
8319 dBrHXXRatio1 = BrHXXRatio - 1.0;
8320 dBrHXXRatio2 = 0.0;
8321 } else if (fstate == 7){
8322 BrHXXRatio = (myNPbase->BrHZZRatio());
8323 dBrHXXRatio1 = BrHXXRatio - 1.0;
8324 dBrHXXRatio2 = 0.0;
8325 } else {
8326 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8327 }
8328
8329 //-- Production x Decay:
8330 if ((this->getModel()).isModelLinearized()){
8331 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8332 } else if((this->getModel()).isModelNPquadratic()){
8333 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8334 } else {
8335 return weight*(muProd)*(BrHXXRatio);
8336 }
8337
8338}
8339
8340
8341// -----------------------------------------------------------------------------
8342
8343
8344//VM:STXS2024;
8345STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8346: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8347{
8348 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8349 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8350
8351}
8352
8354{
8355 //-- Production:
8356 double weight = 1.0; //If normalized to the SM
8357 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8358 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8359 double muProd1 = muProd -1.0;
8360 double muProd2 = 0.0;
8361
8362 //-- Decay:
8363 double BrHXXRatio = 1.0;
8364 double dBrHXXRatio1 = 0.0;
8365 double dBrHXXRatio2 = 0.0;
8366 if (fstate==0){
8367 // Use for Cross-section [pb] with no Higgs-boson decay
8368 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8369 } else if (fstate == 1){
8370 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8371 dBrHXXRatio1 = BrHXXRatio - 1.0;
8372 dBrHXXRatio2 = 0.0;
8373 } else if (fstate == 2){
8374 BrHXXRatio = (myNPbase->BrHgagaRatio());
8375 dBrHXXRatio1 = BrHXXRatio - 1.0;
8376 dBrHXXRatio2 = 0.0;
8377 } else if (fstate == 3){
8378 BrHXXRatio = (myNPbase->BrHbbRatio());
8379 dBrHXXRatio1 = BrHXXRatio - 1.0;
8380 dBrHXXRatio2 = 0.0;
8381 } else if (fstate == 4){
8382 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8383 dBrHXXRatio1 = BrHXXRatio - 1.0;
8384 dBrHXXRatio2 = 0.0;
8385 } else if (fstate == 5){
8386 BrHXXRatio = (myNPbase->BrHtautauRatio());
8387 dBrHXXRatio1 = BrHXXRatio - 1.0;
8388 dBrHXXRatio2 = 0.0;
8389 } else if (fstate == 6){
8390 BrHXXRatio = (myNPbase->BrHWWRatio());
8391 dBrHXXRatio1 = BrHXXRatio - 1.0;
8392 dBrHXXRatio2 = 0.0;
8393 } else if (fstate == 7){
8394 BrHXXRatio = (myNPbase->BrHZZRatio());
8395 dBrHXXRatio1 = BrHXXRatio - 1.0;
8396 dBrHXXRatio2 = 0.0;
8397 } else {
8398 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8399 }
8400
8401 //-- Production x Decay:
8402 if ((this->getModel()).isModelLinearized()){
8403 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8404 } else if((this->getModel()).isModelNPquadratic()){
8405 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8406 } else {
8407 return weight*(muProd)*(BrHXXRatio);
8408 }
8409
8410}
8411
8412
8413
8414// -----------------------------------------------------------------------------
8415
8416
8417//VM:STXS2024;
8418STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8419: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8420{
8421 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8422 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8423
8424}
8425
8427{
8428 //-- Production:
8429 double weight = 1.0; //If normalized to the SM
8430 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8431 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8432 double muProd1 = muProd -1.0;
8433 double muProd2 = 0.0;
8434
8435 //-- Decay:
8436 double BrHXXRatio = 1.0;
8437 double dBrHXXRatio1 = 0.0;
8438 double dBrHXXRatio2 = 0.0;
8439 if (fstate==0){
8440 // Use for Cross-section [pb] with no Higgs-boson decay
8441 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8442 } else if (fstate == 1){
8443 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8444 dBrHXXRatio1 = BrHXXRatio - 1.0;
8445 dBrHXXRatio2 = 0.0;
8446 } else if (fstate == 2){
8447 BrHXXRatio = (myNPbase->BrHgagaRatio());
8448 dBrHXXRatio1 = BrHXXRatio - 1.0;
8449 dBrHXXRatio2 = 0.0;
8450 } else if (fstate == 3){
8451 BrHXXRatio = (myNPbase->BrHbbRatio());
8452 dBrHXXRatio1 = BrHXXRatio - 1.0;
8453 dBrHXXRatio2 = 0.0;
8454 } else if (fstate == 4){
8455 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8456 dBrHXXRatio1 = BrHXXRatio - 1.0;
8457 dBrHXXRatio2 = 0.0;
8458 } else if (fstate == 5){
8459 BrHXXRatio = (myNPbase->BrHtautauRatio());
8460 dBrHXXRatio1 = BrHXXRatio - 1.0;
8461 dBrHXXRatio2 = 0.0;
8462 } else if (fstate == 6){
8463 BrHXXRatio = (myNPbase->BrHWWRatio());
8464 dBrHXXRatio1 = BrHXXRatio - 1.0;
8465 dBrHXXRatio2 = 0.0;
8466 } else if (fstate == 7){
8467 BrHXXRatio = (myNPbase->BrHZZRatio());
8468 dBrHXXRatio1 = BrHXXRatio - 1.0;
8469 dBrHXXRatio2 = 0.0;
8470 } else {
8471 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8472 }
8473
8474 //-- Production x Decay:
8475 if ((this->getModel()).isModelLinearized()){
8476 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8477 } else if((this->getModel()).isModelNPquadratic()){
8478 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8479 } else {
8480 return weight*(muProd)*(BrHXXRatio);
8481 }
8482
8483}
8484
8485
8486
8487
8488// -----------------------------------------------------------------------------
8489
8490
8491//VM:STXS2024;
8492STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8493: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8494{
8495 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8496 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8497
8498}
8499
8501{
8502 //-- Production:
8503 double weight = 1.0; //If normalized to the SM
8504 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8505 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8506 double muProd1 = muProd -1.0;
8507 double muProd2 = 0.0;
8508
8509 //-- Decay:
8510 double BrHXXRatio = 1.0;
8511 double dBrHXXRatio1 = 0.0;
8512 double dBrHXXRatio2 = 0.0;
8513 if (fstate==0){
8514 // Use for Cross-section [pb] with no Higgs-boson decay
8515 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8516 } else if (fstate == 1){
8517 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8518 dBrHXXRatio1 = BrHXXRatio - 1.0;
8519 dBrHXXRatio2 = 0.0;
8520 } else if (fstate == 2){
8521 BrHXXRatio = (myNPbase->BrHgagaRatio());
8522 dBrHXXRatio1 = BrHXXRatio - 1.0;
8523 dBrHXXRatio2 = 0.0;
8524 } else if (fstate == 3){
8525 BrHXXRatio = (myNPbase->BrHbbRatio());
8526 dBrHXXRatio1 = BrHXXRatio - 1.0;
8527 dBrHXXRatio2 = 0.0;
8528 } else if (fstate == 4){
8529 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8530 dBrHXXRatio1 = BrHXXRatio - 1.0;
8531 dBrHXXRatio2 = 0.0;
8532 } else if (fstate == 5){
8533 BrHXXRatio = (myNPbase->BrHtautauRatio());
8534 dBrHXXRatio1 = BrHXXRatio - 1.0;
8535 dBrHXXRatio2 = 0.0;
8536 } else if (fstate == 6){
8537 BrHXXRatio = (myNPbase->BrHWWRatio());
8538 dBrHXXRatio1 = BrHXXRatio - 1.0;
8539 dBrHXXRatio2 = 0.0;
8540 } else if (fstate == 7){
8541 BrHXXRatio = (myNPbase->BrHZZRatio());
8542 dBrHXXRatio1 = BrHXXRatio - 1.0;
8543 dBrHXXRatio2 = 0.0;
8544 } else {
8545 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8546 }
8547
8548 //-- Production x Decay:
8549 if ((this->getModel()).isModelLinearized()){
8550 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8551 } else if((this->getModel()).isModelNPquadratic()){
8552 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8553 } else {
8554 return weight*(muProd)*(BrHXXRatio);
8555 }
8556
8557}
8558
8559
8560
8561// -----------------------------------------------------------------------------
8562
8563
8564//VM:STXS2024;
8565STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8566: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8567{
8568 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8569 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8570
8571}
8572
8574{
8575 //-- Production:
8576 double weight = 1.0; //If normalized to the SM
8577 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8578 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8579 double muProd1 = muProd -1.0;
8580 double muProd2 = 0.0;
8581
8582 //-- Decay:
8583 double BrHXXRatio = 1.0;
8584 double dBrHXXRatio1 = 0.0;
8585 double dBrHXXRatio2 = 0.0;
8586 if (fstate==0){
8587 // Use for Cross-section [pb] with no Higgs-boson decay
8588 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8589 } else if (fstate == 1){
8590 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8591 dBrHXXRatio1 = BrHXXRatio - 1.0;
8592 dBrHXXRatio2 = 0.0;
8593 } else if (fstate == 2){
8594 BrHXXRatio = (myNPbase->BrHgagaRatio());
8595 dBrHXXRatio1 = BrHXXRatio - 1.0;
8596 dBrHXXRatio2 = 0.0;
8597 } else if (fstate == 3){
8598 BrHXXRatio = (myNPbase->BrHbbRatio());
8599 dBrHXXRatio1 = BrHXXRatio - 1.0;
8600 dBrHXXRatio2 = 0.0;
8601 } else if (fstate == 4){
8602 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8603 dBrHXXRatio1 = BrHXXRatio - 1.0;
8604 dBrHXXRatio2 = 0.0;
8605 } else if (fstate == 5){
8606 BrHXXRatio = (myNPbase->BrHtautauRatio());
8607 dBrHXXRatio1 = BrHXXRatio - 1.0;
8608 dBrHXXRatio2 = 0.0;
8609 } else if (fstate == 6){
8610 BrHXXRatio = (myNPbase->BrHWWRatio());
8611 dBrHXXRatio1 = BrHXXRatio - 1.0;
8612 dBrHXXRatio2 = 0.0;
8613 } else if (fstate == 7){
8614 BrHXXRatio = (myNPbase->BrHZZRatio());
8615 dBrHXXRatio1 = BrHXXRatio - 1.0;
8616 dBrHXXRatio2 = 0.0;
8617 } else {
8618 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8619 }
8620
8621 //-- Production x Decay:
8622 if ((this->getModel()).isModelLinearized()){
8623 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8624 } else if((this->getModel()).isModelNPquadratic()){
8625 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8626 } else {
8627 return weight*(muProd)*(BrHXXRatio);
8628 }
8629
8630}
8631
8632
8633
8634// -----------------------------------------------------------------------------
8635
8636
8637//VM:STXS2024;
8638STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8639: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8640{
8641 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8642 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8643
8644}
8645
8647{
8648 //-- Production:
8649 double weight = 1.0; //If normalized to the SM
8650 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8651 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8652 double muProd1 = muProd -1.0;
8653 double muProd2 = 0.0;
8654
8655 //-- Decay:
8656 double BrHXXRatio = 1.0;
8657 double dBrHXXRatio1 = 0.0;
8658 double dBrHXXRatio2 = 0.0;
8659 if (fstate==0){
8660 // Use for Cross-section [pb] with no Higgs-boson decay
8661 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8662 } else if (fstate == 1){
8663 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8664 dBrHXXRatio1 = BrHXXRatio - 1.0;
8665 dBrHXXRatio2 = 0.0;
8666 } else if (fstate == 2){
8667 BrHXXRatio = (myNPbase->BrHgagaRatio());
8668 dBrHXXRatio1 = BrHXXRatio - 1.0;
8669 dBrHXXRatio2 = 0.0;
8670 } else if (fstate == 3){
8671 BrHXXRatio = (myNPbase->BrHbbRatio());
8672 dBrHXXRatio1 = BrHXXRatio - 1.0;
8673 dBrHXXRatio2 = 0.0;
8674 } else if (fstate == 4){
8675 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8676 dBrHXXRatio1 = BrHXXRatio - 1.0;
8677 dBrHXXRatio2 = 0.0;
8678 } else if (fstate == 5){
8679 BrHXXRatio = (myNPbase->BrHtautauRatio());
8680 dBrHXXRatio1 = BrHXXRatio - 1.0;
8681 dBrHXXRatio2 = 0.0;
8682 } else if (fstate == 6){
8683 BrHXXRatio = (myNPbase->BrHWWRatio());
8684 dBrHXXRatio1 = BrHXXRatio - 1.0;
8685 dBrHXXRatio2 = 0.0;
8686 } else if (fstate == 7){
8687 BrHXXRatio = (myNPbase->BrHZZRatio());
8688 dBrHXXRatio1 = BrHXXRatio - 1.0;
8689 dBrHXXRatio2 = 0.0;
8690 } else {
8691 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8692 }
8693
8694 //-- Production x Decay:
8695 if ((this->getModel()).isModelLinearized()){
8696 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8697 } else if((this->getModel()).isModelNPquadratic()){
8698 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8699 } else {
8700 return weight*(muProd)*(BrHXXRatio);
8701 }
8702
8703}
8704
8705
8706// -----------------------------------------------------------------------------
8707
8708STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8709: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8710{
8711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8712 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8713
8714}
8715
8717{
8718 double BrHXXRatio = 1.0;
8719 if (fstate == 1){
8720 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8721 } else if (fstate == 2){
8722 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8723 } else if (fstate == 3){
8724 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8725 } else if (fstate == 4){
8726 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8727 } else {
8728 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8729 }
8730
8731 if ((this->getModel()).isModelLinearized()) {
8732 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8733 } else {
8734 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8735 }
8736}
8737
8738// -----------------------------------------------------------------------------
8739
8740STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8741: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8742{
8743 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8744 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8745
8746}
8747
8749{
8750 double BrHXXRatio = 1.0;
8751 if (fstate == 1){
8752 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8753 } else if (fstate == 2){
8754 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8755 } else if (fstate == 3){
8756 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8757 } else if (fstate == 4){
8758 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8759 } else {
8760 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8761 }
8762
8763 if ((this->getModel()).isModelLinearized()) {
8764 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8765 } else {
8766 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8767 }
8768}
8769
8770// -----------------------------------------------------------------------------
8771
8772STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8773: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8774{
8775 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8776 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8777
8778}
8779
8781{
8782 double BrHXXRatio = 1.0;
8783 if (fstate == 1){
8784 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8785 } else if (fstate == 2){
8786 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8787 } else if (fstate == 3){
8788 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8789 } else if (fstate == 4){
8790 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8791 } else {
8792 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8793 }
8794
8795 if ((this->getModel()).isModelLinearized()) {
8796 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8797 } else {
8798 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8799 }
8800}
8801
8802// -----------------------------------------------------------------------------
8803
8804STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8805: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8806{
8807 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8808 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8809
8810}
8811
8813{
8814 double BrHXXRatio = 1.0;
8815 if (fstate == 1){
8816 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8817 } else if (fstate == 2){
8818 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8819 } else if (fstate == 3){
8820 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8821 } else if (fstate == 4){
8822 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8823 } else {
8824 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8825 }
8826
8827 if ((this->getModel()).isModelLinearized()) {
8828 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8829 } else {
8830 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8831 }
8832}
8833
8834// -----------------------------------------------------------------------------
8835
8836STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8837: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8838{
8839 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8840 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8841
8842}
8843
8845{
8846 double BrHXXRatio = 1.0;
8847 if (fstate == 1){
8848 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8849 } else if (fstate == 2){
8850 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8851 } else if (fstate == 3){
8852 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8853 } else if (fstate == 4){
8854 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8855 } else {
8856 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8857 }
8858
8859 if ((this->getModel()).isModelLinearized()) {
8860 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8861 } else {
8862 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8863 }
8864}
8865
8866// -----------------------------------------------------------------------------
8867
8868STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8869: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8870{
8871 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8872 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8873
8874}
8875
8877{
8878 double BrHXXRatio = 1.0;
8879 if (fstate == 1){
8880 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8881 } else if (fstate == 2){
8882 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8883 } else if (fstate == 3){
8884 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8885 } else if (fstate == 4){
8886 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8887 } else {
8888 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8889 }
8890
8891 if ((this->getModel()).isModelLinearized()) {
8892 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8893 } else {
8894 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8895 }
8896}
8897
8898// -----------------------------------------------------------------------------
8899
8900STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8901: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8902{
8903 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8904 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8905
8906}
8907
8909{
8910 double BrHXXRatio = 1.0;
8911 if (fstate == 1){
8912 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8913 } else if (fstate == 2){
8914 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8915 } else if (fstate == 3){
8916 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8917 } else if (fstate == 4){
8918 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8919 } else {
8920 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8921 }
8922
8923 if ((this->getModel()).isModelLinearized()) {
8924 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8925 } else {
8926 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8927 }
8928}
8929
8930// -----------------------------------------------------------------------------
8931
8932STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8933: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8934{
8935 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8936 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8937
8938}
8939
8941{
8942 double BrHXXRatio = 1.0;
8943 if (fstate == 1){
8944 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8945 } else if (fstate == 2){
8946 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8947 } else if (fstate == 3){
8948 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8949 } else if (fstate == 4){
8950 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8951 } else {
8952 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8953 }
8954
8955 if ((this->getModel()).isModelLinearized()) {
8956 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8957 } else {
8958 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
8959 }
8960}
8961
8962
8963
8964// -----------------------------------------------------------------------------
8965
8966
8967//VM:STXS2024;
8968STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8969: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8970{
8971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8972 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
8973
8974}
8975
8977{
8978 //-- Production:
8979 double weight = 1.0; //If normalized to the SM
8980 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8981 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
8982 double muProd1 = muProd -1.0;
8983 double muProd2 = 0.0;
8984
8985 //-- Decay:
8986 double BrHXXRatio = 1.0;
8987 double dBrHXXRatio1 = 0.0;
8988 double dBrHXXRatio2 = 0.0;
8989 if (fstate==0){
8990 // Use for Cross-section [pb] with no Higgs-boson decay
8991 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8992 } else if (fstate == 1){
8993 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8994 dBrHXXRatio1 = BrHXXRatio - 1.0;
8995 dBrHXXRatio2 = 0.0;
8996 } else if (fstate == 2){
8997 BrHXXRatio = (myNPbase->BrHgagaRatio());
8998 dBrHXXRatio1 = BrHXXRatio - 1.0;
8999 dBrHXXRatio2 = 0.0;
9000 } else if (fstate == 3){
9001 BrHXXRatio = (myNPbase->BrHbbRatio());
9002 dBrHXXRatio1 = BrHXXRatio - 1.0;
9003 dBrHXXRatio2 = 0.0;
9004 } else if (fstate == 4){
9005 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9006 dBrHXXRatio1 = BrHXXRatio - 1.0;
9007 dBrHXXRatio2 = 0.0;
9008 } else if (fstate == 5){
9009 BrHXXRatio = (myNPbase->BrHtautauRatio());
9010 dBrHXXRatio1 = BrHXXRatio - 1.0;
9011 dBrHXXRatio2 = 0.0;
9012 } else if (fstate == 6){
9013 BrHXXRatio = (myNPbase->BrHWWRatio());
9014 dBrHXXRatio1 = BrHXXRatio - 1.0;
9015 dBrHXXRatio2 = 0.0;
9016 } else if (fstate == 7){
9017 BrHXXRatio = (myNPbase->BrHZZRatio());
9018 dBrHXXRatio1 = BrHXXRatio - 1.0;
9019 dBrHXXRatio2 = 0.0;
9020 } else {
9021 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9022 }
9023
9024 //-- Production x Decay:
9025 if ((this->getModel()).isModelLinearized()){
9026 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9027 } else if((this->getModel()).isModelNPquadratic()){
9028 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9029 } else {
9030 return weight*(muProd)*(BrHXXRatio);
9031 }
9032
9033}
9034
9035
9036
9037
9038// -----------------------------------------------------------------------------
9039
9040
9041//VM:STXS2024;
9042STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9043: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9044{
9045 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9046 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9047
9048}
9049
9051{
9052 //-- Production:
9053 double weight = 1.0; //If normalized to the SM
9054 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9055 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9056 double muProd1 = muProd -1.0;
9057 double muProd2 = 0.0;
9058
9059 //-- Decay:
9060 double BrHXXRatio = 1.0;
9061 double dBrHXXRatio1 = 0.0;
9062 double dBrHXXRatio2 = 0.0;
9063 if (fstate==0){
9064 // Use for Cross-section [pb] with no Higgs-boson decay
9065 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9066 } else if (fstate == 1){
9067 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9068 dBrHXXRatio1 = BrHXXRatio - 1.0;
9069 dBrHXXRatio2 = 0.0;
9070 } else if (fstate == 2){
9071 BrHXXRatio = (myNPbase->BrHgagaRatio());
9072 dBrHXXRatio1 = BrHXXRatio - 1.0;
9073 dBrHXXRatio2 = 0.0;
9074 } else if (fstate == 3){
9075 BrHXXRatio = (myNPbase->BrHbbRatio());
9076 dBrHXXRatio1 = BrHXXRatio - 1.0;
9077 dBrHXXRatio2 = 0.0;
9078 } else if (fstate == 4){
9079 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9080 dBrHXXRatio1 = BrHXXRatio - 1.0;
9081 dBrHXXRatio2 = 0.0;
9082 } else if (fstate == 5){
9083 BrHXXRatio = (myNPbase->BrHtautauRatio());
9084 dBrHXXRatio1 = BrHXXRatio - 1.0;
9085 dBrHXXRatio2 = 0.0;
9086 } else if (fstate == 6){
9087 BrHXXRatio = (myNPbase->BrHWWRatio());
9088 dBrHXXRatio1 = BrHXXRatio - 1.0;
9089 dBrHXXRatio2 = 0.0;
9090 } else if (fstate == 7){
9091 BrHXXRatio = (myNPbase->BrHZZRatio());
9092 dBrHXXRatio1 = BrHXXRatio - 1.0;
9093 dBrHXXRatio2 = 0.0;
9094 } else {
9095 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9096 }
9097
9098 //-- Production x Decay:
9099 if ((this->getModel()).isModelLinearized()){
9100 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9101 } else if((this->getModel()).isModelNPquadratic()){
9102 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9103 } else {
9104 return weight*(muProd)*(BrHXXRatio);
9105 }
9106
9107}
9108
9109
9110
9111// -----------------------------------------------------------------------------
9112
9113//AG:STXS2024
9114STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9115: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9116{
9117 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9118 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9119
9120}
9121
9123{
9124 //-- Production:
9125 double weight = 1.0; //If normalized to the SM
9126 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9127 double muProd1 = muProd -1.0;
9128 double muProd2 = 0.0;
9129
9130 //-- Decay:
9131 double BrHXXRatio = 1.0;
9132 double dBrHXXRatio1 = 0.0;
9133 double dBrHXXRatio2 = 0.0;
9134 if (fstate==0){
9135 // Use for Cross-section [pb] with no Higgs-boson decay
9136 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9137 } else if (fstate == 1){
9138 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9139 dBrHXXRatio1 = BrHXXRatio - 1.0;
9140 dBrHXXRatio2 = 0.0;
9141 } else if (fstate == 2){
9142 BrHXXRatio = (myNPbase->BrHgagaRatio());
9143 dBrHXXRatio1 = BrHXXRatio - 1.0;
9144 dBrHXXRatio2 = 0.0;
9145 } else if (fstate == 3){
9146 BrHXXRatio = (myNPbase->BrHbbRatio());
9147 dBrHXXRatio1 = BrHXXRatio - 1.0;
9148 dBrHXXRatio2 = 0.0;
9149 } else if (fstate == 4){
9150 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9151 dBrHXXRatio1 = BrHXXRatio - 1.0;
9152 dBrHXXRatio2 = 0.0;
9153 } else if (fstate == 5){
9154 BrHXXRatio = (myNPbase->BrHtautauRatio());
9155 dBrHXXRatio1 = BrHXXRatio - 1.0;
9156 dBrHXXRatio2 = 0.0;
9157 } else if (fstate == 6){
9158 BrHXXRatio = (myNPbase->BrHWWRatio());
9159 dBrHXXRatio1 = BrHXXRatio - 1.0;
9160 dBrHXXRatio2 = 0.0;
9161 } else if (fstate == 7){
9162 BrHXXRatio = (myNPbase->BrHZZRatio());
9163 dBrHXXRatio1 = BrHXXRatio - 1.0;
9164 dBrHXXRatio2 = 0.0;
9165 } else {
9166 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9167 }
9168
9169 //-- Production x Decay:
9170 if ((this->getModel()).isModelLinearized()){
9171 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9172 } else if((this->getModel()).isModelNPquadratic()){
9173 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9174 } else {
9175 return weight*(muProd)*(BrHXXRatio);
9176 }
9177}
9178
9179// -----------------------------------------------------------------------------
9180
9181STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9182: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9183{
9184 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9185 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9186
9187}
9188
9190{
9191 double BrHXXRatio = 1.0;
9192 if (fstate == 1){
9193 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9194 } else if (fstate == 2){
9195 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9196 } else if (fstate == 3){
9197 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9198 } else if (fstate == 4){
9199 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9200 } else {
9201 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9202 }
9203
9204 if ((this->getModel()).isModelLinearized()) {
9205 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9206 } else {
9207 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9208 }
9209}
9210
9211// -----------------------------------------------------------------------------
9212
9213//AG:STXS2024
9215: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9216{
9217 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9218 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9219
9220}
9221
9223{
9224 //-- Production:
9225 double weight = 1.0; //If normalized to the SM
9227 double muProd1 = muProd -1.0;
9228 double muProd2 = 0.0;
9229
9230 //-- Decay:
9231 double BrHXXRatio = 1.0;
9232 double dBrHXXRatio1 = 0.0;
9233 double dBrHXXRatio2 = 0.0;
9234 if (fstate==0){
9235 // Use for Cross-section [pb] with no Higgs-boson decay
9236 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9237 } else if (fstate == 1){
9238 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9239 dBrHXXRatio1 = BrHXXRatio - 1.0;
9240 dBrHXXRatio2 = 0.0;
9241 } else if (fstate == 2){
9242 BrHXXRatio = (myNPbase->BrHgagaRatio());
9243 dBrHXXRatio1 = BrHXXRatio - 1.0;
9244 dBrHXXRatio2 = 0.0;
9245 } else if (fstate == 3){
9246 BrHXXRatio = (myNPbase->BrHbbRatio());
9247 dBrHXXRatio1 = BrHXXRatio - 1.0;
9248 dBrHXXRatio2 = 0.0;
9249 } else if (fstate == 4){
9250 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9251 dBrHXXRatio1 = BrHXXRatio - 1.0;
9252 dBrHXXRatio2 = 0.0;
9253 } else if (fstate == 5){
9254 BrHXXRatio = (myNPbase->BrHtautauRatio());
9255 dBrHXXRatio1 = BrHXXRatio - 1.0;
9256 dBrHXXRatio2 = 0.0;
9257 } else if (fstate == 6){
9258 BrHXXRatio = (myNPbase->BrHWWRatio());
9259 dBrHXXRatio1 = BrHXXRatio - 1.0;
9260 dBrHXXRatio2 = 0.0;
9261 } else if (fstate == 7){
9262 BrHXXRatio = (myNPbase->BrHZZRatio());
9263 dBrHXXRatio1 = BrHXXRatio - 1.0;
9264 dBrHXXRatio2 = 0.0;
9265 } else {
9266 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9267 }
9268
9269
9270 //-- Production x Decay:
9271 if ((this->getModel()).isModelLinearized()){
9272 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9273 } else if((this->getModel()).isModelNPquadratic()){
9274 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9275 } else {
9276 return weight*(muProd)*(BrHXXRatio);
9277 }
9278
9279}
9280
9281// -----------------------------------------------------------------------------
9282
9284: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9285{
9286 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9287 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9288
9289}
9290
9292{
9293 double BrHXXRatio = 1.0;
9294 if (fstate == 1){
9295 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9296 } else if (fstate == 2){
9297 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9298 } else if (fstate == 3){
9299 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9300 } else if (fstate == 4){
9301 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9302 } else {
9303 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9304 }
9305
9306 if ((this->getModel()).isModelLinearized()) {
9307 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9308 } else {
9310 }
9311}
9312
9313// -----------------------------------------------------------------------------
9314
9316: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9317{
9318 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9319 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9320
9321}
9322
9324{
9325 double BrHXXRatio = 1.0;
9326 if (fstate == 1){
9327 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9328 } else if (fstate == 2){
9329 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9330 } else if (fstate == 3){
9331 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9332 } else if (fstate == 4){
9333 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9334 } else {
9335 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9336 }
9337
9338 if ((this->getModel()).isModelLinearized()) {
9339 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9340 } else {
9342 }
9343}
9344
9345// -----------------------------------------------------------------------------
9346
9348: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9349{
9350 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9351 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9352
9353}
9354
9356{
9357 double BrHXXRatio = 1.0;
9358 if (fstate == 1){
9359 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9360 } else if (fstate == 2){
9361 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9362 } else if (fstate == 3){
9363 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9364 } else if (fstate == 4){
9365 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9366 } else {
9367 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9368 }
9369
9370 if ((this->getModel()).isModelLinearized()) {
9371 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9372 } else {
9374 }
9375}
9376
9377// -----------------------------------------------------------------------------
9378
9380: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9381{
9382 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9383 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9384
9385}
9386
9388{
9389 double BrHXXRatio = 1.0;
9390 if (fstate == 1){
9391 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9392 } else if (fstate == 2){
9393 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9394 } else if (fstate == 3){
9395 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9396 } else if (fstate == 4){
9397 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9398 } else {
9399 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9400 }
9401
9402 if ((this->getModel()).isModelLinearized()) {
9403 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9404 } else {
9406 }
9407}
9408
9409// -----------------------------------------------------------------------------
9410
9411//AG:STXS2024
9412STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9413: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9414{
9415 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9416 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9417
9418}
9419
9421{
9422 //-- Production:
9423 double weight = 1.0; //If normalized to the SM
9425 double muProd1 = muProd -1.0;
9426 double muProd2 = 0.0;
9427
9428 //-- Decay:
9429 double BrHXXRatio = 1.0;
9430 double dBrHXXRatio1 = 0.0;
9431 double dBrHXXRatio2 = 0.0;
9432 if (fstate==0){
9433 // Use for Cross-section [pb] with no Higgs-boson decay
9434 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9435 } else if (fstate == 1){
9436 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9437 dBrHXXRatio1 = BrHXXRatio - 1.0;
9438 dBrHXXRatio2 = 0.0;
9439 } else if (fstate == 2){
9440 BrHXXRatio = (myNPbase->BrHgagaRatio());
9441 dBrHXXRatio1 = BrHXXRatio - 1.0;
9442 dBrHXXRatio2 = 0.0;
9443 } else if (fstate == 3){
9444 BrHXXRatio = (myNPbase->BrHbbRatio());
9445 dBrHXXRatio1 = BrHXXRatio - 1.0;
9446 dBrHXXRatio2 = 0.0;
9447 } else if (fstate == 4){
9448 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9449 dBrHXXRatio1 = BrHXXRatio - 1.0;
9450 dBrHXXRatio2 = 0.0;
9451 } else if (fstate == 5){
9452 BrHXXRatio = (myNPbase->BrHtautauRatio());
9453 dBrHXXRatio1 = BrHXXRatio - 1.0;
9454 dBrHXXRatio2 = 0.0;
9455 } else if (fstate == 6){
9456 BrHXXRatio = (myNPbase->BrHWWRatio());
9457 dBrHXXRatio1 = BrHXXRatio - 1.0;
9458 dBrHXXRatio2 = 0.0;
9459 } else {
9460 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9461 }
9462
9463 //-- Production x Decay:
9464 if ((this->getModel()).isModelLinearized()){
9465 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9466 } else if((this->getModel()).isModelNPquadratic()){
9467 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9468 } else {
9469 return weight*(muProd)*(BrHXXRatio);
9470 }
9471
9472
9473}
9474
9475// -----------------------------------------------------------------------------
9476
9477//AG:STXS2024
9478STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9479: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9480{
9481 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9482 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9483
9484}
9485
9487{
9488 //-- Production:
9489 double weight = 1.0; //If normalized to the SM
9491 double muProd1 = muProd -1.0;
9492 double muProd2 = 0.0;
9493
9494 //-- Decay:
9495 double BrHXXRatio = 1.0;
9496 double dBrHXXRatio1 = 0.0;
9497 double dBrHXXRatio2 = 0.0;
9498 if (fstate==0){
9499 // Use for Cross-section [pb] with no Higgs-boson decay
9500 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9501 } else if (fstate == 1){
9502 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9503 dBrHXXRatio1 = BrHXXRatio - 1.0;
9504 dBrHXXRatio2 = 0.0;
9505 } else if (fstate == 2){
9506 BrHXXRatio = (myNPbase->BrHgagaRatio());
9507 dBrHXXRatio1 = BrHXXRatio - 1.0;
9508 dBrHXXRatio2 = 0.0;
9509 } else if (fstate == 3){
9510 BrHXXRatio = (myNPbase->BrHbbRatio());
9511 dBrHXXRatio1 = BrHXXRatio - 1.0;
9512 dBrHXXRatio2 = 0.0;
9513 } else if (fstate == 4){
9514 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9515 dBrHXXRatio1 = BrHXXRatio - 1.0;
9516 dBrHXXRatio2 = 0.0;
9517 } else if (fstate == 5){
9518 BrHXXRatio = (myNPbase->BrHtautauRatio());
9519 dBrHXXRatio1 = BrHXXRatio - 1.0;
9520 dBrHXXRatio2 = 0.0;
9521 } else if (fstate == 6){
9522 BrHXXRatio = (myNPbase->BrHWWRatio());
9523 dBrHXXRatio1 = BrHXXRatio - 1.0;
9524 dBrHXXRatio2 = 0.0;
9525 } else {
9526 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9527 }
9528
9529 //-- Production x Decay:
9530 if ((this->getModel()).isModelLinearized()){
9531 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9532 } else if((this->getModel()).isModelNPquadratic()){
9533 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9534 } else {
9535 return weight*(muProd)*(BrHXXRatio);
9536 }
9537
9538
9539}
9540
9541// -----------------------------------------------------------------------------
9542
9543//AG:STXS2024
9544STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9545: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9546{
9547 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9548 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9549
9550}
9551
9553{
9554 //-- Production:
9555 double weight = 1.0; //If normalized to the SM
9557 double muProd1 = muProd -1.0;
9558 double muProd2 = 0.0;
9559
9560 //-- Decay:
9561 double BrHXXRatio = 1.0;
9562 double dBrHXXRatio1 = 0.0;
9563 double dBrHXXRatio2 = 0.0;
9564 if (fstate==0){
9565 // Use for Cross-section [pb] with no Higgs-boson decay
9566 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9567 } else if (fstate == 1){
9568 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9569 dBrHXXRatio1 = BrHXXRatio - 1.0;
9570 dBrHXXRatio2 = 0.0;
9571 } else if (fstate == 2){
9572 BrHXXRatio = (myNPbase->BrHgagaRatio());
9573 dBrHXXRatio1 = BrHXXRatio - 1.0;
9574 dBrHXXRatio2 = 0.0;
9575 } else if (fstate == 3){
9576 BrHXXRatio = (myNPbase->BrHbbRatio());
9577 dBrHXXRatio1 = BrHXXRatio - 1.0;
9578 dBrHXXRatio2 = 0.0;
9579 } else if (fstate == 4){
9580 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9581 dBrHXXRatio1 = BrHXXRatio - 1.0;
9582 dBrHXXRatio2 = 0.0;
9583 } else if (fstate == 5){
9584 BrHXXRatio = (myNPbase->BrHtautauRatio());
9585 dBrHXXRatio1 = BrHXXRatio - 1.0;
9586 dBrHXXRatio2 = 0.0;
9587 } else if (fstate == 6){
9588 BrHXXRatio = (myNPbase->BrHWWRatio());
9589 dBrHXXRatio1 = BrHXXRatio - 1.0;
9590 dBrHXXRatio2 = 0.0;
9591 } else {
9592 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9593 }
9594
9595 //-- Production x Decay:
9596 if ((this->getModel()).isModelLinearized()){
9597 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9598 } else if((this->getModel()).isModelNPquadratic()){
9599 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9600 } else {
9601 return weight*(muProd)*(BrHXXRatio);
9602 }
9603
9604
9605}
9606
9607// -----------------------------------------------------------------------------
9608
9609//AG:STXS2024
9610STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9611: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9612{
9613 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9614 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9615
9616}
9617
9619{
9620 //-- Production:
9621 double weight = 1.0; //If normalized to the SM
9623 double muProd1 = muProd -1.0;
9624 double muProd2 = 0.0;
9625
9626 //-- Decay:
9627 double BrHXXRatio = 1.0;
9628 double dBrHXXRatio1 = 0.0;
9629 double dBrHXXRatio2 = 0.0;
9630 if (fstate==0){
9631 // Use for Cross-section [pb] with no Higgs-boson decay
9632 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9633 } else if (fstate == 1){
9634 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9635 dBrHXXRatio1 = BrHXXRatio - 1.0;
9636 dBrHXXRatio2 = 0.0;
9637 } else if (fstate == 2){
9638 BrHXXRatio = (myNPbase->BrHgagaRatio());
9639 dBrHXXRatio1 = BrHXXRatio - 1.0;
9640 dBrHXXRatio2 = 0.0;
9641 } else if (fstate == 3){
9642 BrHXXRatio = (myNPbase->BrHbbRatio());
9643 dBrHXXRatio1 = BrHXXRatio - 1.0;
9644 dBrHXXRatio2 = 0.0;
9645 } else if (fstate == 4){
9646 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9647 dBrHXXRatio1 = BrHXXRatio - 1.0;
9648 dBrHXXRatio2 = 0.0;
9649 } else if (fstate == 5){
9650 BrHXXRatio = (myNPbase->BrHtautauRatio());
9651 dBrHXXRatio1 = BrHXXRatio - 1.0;
9652 dBrHXXRatio2 = 0.0;
9653 } else if (fstate == 6){
9654 BrHXXRatio = (myNPbase->BrHWWRatio());
9655 dBrHXXRatio1 = BrHXXRatio - 1.0;
9656 dBrHXXRatio2 = 0.0;
9657 } else {
9658 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9659 }
9660
9661 //-- Production x Decay:
9662 if ((this->getModel()).isModelLinearized()){
9663 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9664 } else if((this->getModel()).isModelNPquadratic()){
9665 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9666 } else {
9667 return weight*(muProd)*(BrHXXRatio);
9668 }
9669
9670}
9671
9672// -----------------------------------------------------------------------------
9673
9674//AG:STXS2024
9675STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9676: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9677{
9678 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9679 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9680
9681}
9682
9684{
9685 //-- Production:
9686 double weight = 1.0; //If normalized to the SM
9687 //Since adding bins, include partial weigths of SM_predictions
9688 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9689 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9690 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9691 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9692 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9693 double muProd2 = 0.0;
9694
9695 //-- Decay:
9696 double BrHXXRatio = 1.0;
9697 double dBrHXXRatio1 = 0.0;
9698 double dBrHXXRatio2 = 0.0;
9699 if (fstate==0){
9700 // Use for Cross-section [pb] with no Higgs-boson decay
9701 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9702 } else if (fstate == 1){
9703 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9704 dBrHXXRatio1 = BrHXXRatio - 1.0;
9705 dBrHXXRatio2 = 0.0;
9706 } else if (fstate == 2){
9707 BrHXXRatio = (myNPbase->BrHgagaRatio());
9708 dBrHXXRatio1 = BrHXXRatio - 1.0;
9709 dBrHXXRatio2 = 0.0;
9710 } else if (fstate == 3){
9711 BrHXXRatio = (myNPbase->BrHbbRatio());
9712 dBrHXXRatio1 = BrHXXRatio - 1.0;
9713 dBrHXXRatio2 = 0.0;
9714 } else if (fstate == 4){
9715 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9716 dBrHXXRatio1 = BrHXXRatio - 1.0;
9717 dBrHXXRatio2 = 0.0;
9718 } else {
9719 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9720 }
9721
9722 //-- Production x Decay:
9723 if ((this->getModel()).isModelLinearized()){
9724 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9725 } else if((this->getModel()).isModelNPquadratic()){
9726 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9727 } else {
9728 return weight*(muProd)*(BrHXXRatio);
9729 }
9730
9731
9732}
9733
9734// -----------------------------------------------------------------------------
9735
9736//AG:STXS2024
9737STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9738: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9739{
9740 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9741 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9742
9743}
9744
9746{
9747 //-- Production:
9748 double weight = 1.0; //If normalized to the SM
9750 double muProd1 = muProd -1.0;
9751 double muProd2 = 0.0;
9752
9753 //-- Decay:
9754 double BrHXXRatio = 1.0;
9755 double dBrHXXRatio1 = 0.0;
9756 double dBrHXXRatio2 = 0.0;
9757 if (fstate==0){
9758 // Use for Cross-section [pb] with no Higgs-boson decay
9759 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9760 } else if (fstate == 1){
9761 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9762 dBrHXXRatio1 = BrHXXRatio - 1.0;
9763 dBrHXXRatio2 = 0.0;
9764 } else if (fstate == 2){
9765 BrHXXRatio = (myNPbase->BrHgagaRatio());
9766 dBrHXXRatio1 = BrHXXRatio - 1.0;
9767 dBrHXXRatio2 = 0.0;
9768 } else if (fstate == 3){
9769 BrHXXRatio = (myNPbase->BrHbbRatio());
9770 dBrHXXRatio1 = BrHXXRatio - 1.0;
9771 dBrHXXRatio2 = 0.0;
9772 } else if (fstate == 4){
9773 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9774 dBrHXXRatio1 = BrHXXRatio - 1.0;
9775 dBrHXXRatio2 = 0.0;
9776 } else {
9777 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9778 }
9779
9780 //-- Production x Decay:
9781 if ((this->getModel()).isModelLinearized()){
9782 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9783 } else if((this->getModel()).isModelNPquadratic()){
9784 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9785 } else {
9786 return weight*(muProd)*(BrHXXRatio);
9787 }
9788
9789
9790}
9791
9792// -----------------------------------------------------------------------------
9793
9794//AG:STXS2024
9795STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9796: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9797{
9798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9799 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9800
9801}
9802
9804{
9805 //-- Production:
9806 double weight = 1.0; //If normalized to the SM
9808 double muProd1 = muProd -1.0;
9809 double muProd2 = 0.0;
9810
9811 //-- Decay:
9812 double BrHXXRatio = 1.0;
9813 double dBrHXXRatio1 = 0.0;
9814 double dBrHXXRatio2 = 0.0;
9815 if (fstate==0){
9816 // Use for Cross-section [pb] with no Higgs-boson decay
9817 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9818 } else if (fstate == 1){
9819 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9820 dBrHXXRatio1 = BrHXXRatio - 1.0;
9821 dBrHXXRatio2 = 0.0;
9822 } else if (fstate == 2){
9823 BrHXXRatio = (myNPbase->BrHgagaRatio());
9824 dBrHXXRatio1 = BrHXXRatio - 1.0;
9825 dBrHXXRatio2 = 0.0;
9826 } else if (fstate == 3){
9827 BrHXXRatio = (myNPbase->BrHbbRatio());
9828 dBrHXXRatio1 = BrHXXRatio - 1.0;
9829 dBrHXXRatio2 = 0.0;
9830 } else if (fstate == 4){
9831 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9832 dBrHXXRatio1 = BrHXXRatio - 1.0;
9833 dBrHXXRatio2 = 0.0;
9834 } else {
9835 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9836 }
9837
9838 //-- Production x Decay:
9839 if ((this->getModel()).isModelLinearized()){
9840 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9841 } else if((this->getModel()).isModelNPquadratic()){
9842 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9843 } else {
9844 return weight*(muProd)*(BrHXXRatio);
9845 }
9846
9847
9848}
9849
9850// -----------------------------------------------------------------------------
9851
9852STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9853: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9854{
9855 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9856 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9857
9858}
9859
9861{
9862 //-- Production:
9863 double weight = 1.0; //If normalized to the SM
9864 //Since adding bins, include partial weigths of SM_predictions
9865 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9866
9867 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9873 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9874
9875 double muProd1 = muProd - 1.;
9876 double muProd2 = 0.0;
9877
9878 //-- Decay:
9879 double BrHXXRatio = 1.0;
9880 double dBrHXXRatio1 = 0.0;
9881 double dBrHXXRatio2 = 0.0;
9882 if (fstate==0){
9883 // Use for Cross-section [pb] with no Higgs-boson decay
9884 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9885 } else if (fstate == 1){
9886 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9887 dBrHXXRatio1 = BrHXXRatio - 1.0;
9888 dBrHXXRatio2 = 0.0;
9889 } else if (fstate == 2){
9890 BrHXXRatio = (myNPbase->BrHgagaRatio());
9891 dBrHXXRatio1 = BrHXXRatio - 1.0;
9892 dBrHXXRatio2 = 0.0;
9893 } else if (fstate == 3){
9894 BrHXXRatio = (myNPbase->BrHbbRatio());
9895 dBrHXXRatio1 = BrHXXRatio - 1.0;
9896 dBrHXXRatio2 = 0.0;
9897 } else if (fstate == 4){
9898 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9899 dBrHXXRatio1 = BrHXXRatio - 1.0;
9900 dBrHXXRatio2 = 0.0;
9901 } else if (fstate == 5){
9902 BrHXXRatio = (myNPbase->BrHtautauRatio());
9903 dBrHXXRatio1 = BrHXXRatio - 1.0;
9904 dBrHXXRatio2 = 0.0;
9905 } else {
9906 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9907 }
9908
9909
9910
9911
9912 //-- Production x Decay:
9913 if ((this->getModel()).isModelLinearized()){
9914// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9915 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9916 } else if((this->getModel()).isModelNPquadratic()){
9917// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9918 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9919 } else {
9920// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9921 return weight*(muProd)*(BrHXXRatio);
9922 }
9923
9924}
9925
9926// -----------------------------------------------------------------------------
9927
9928STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9929: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9930{
9931 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9932 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9933
9934}
9935
9937{
9938 //-- Production:
9939 double weight = 1.0; //If normalized to the SM
9940 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9941 double muProd1 = muProd -1.0;
9942 double muProd2 = 0.0;
9943
9944 //-- Decay:
9945 double BrHXXRatio = 1.0;
9946 double dBrHXXRatio1 = 0.0;
9947 double dBrHXXRatio2 = 0.0;
9948 if (fstate==0){
9949 // Use for Cross-section [pb] with no Higgs-boson decay
9950 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9951 } else if (fstate == 1){
9952 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9953 dBrHXXRatio1 = BrHXXRatio - 1.0;
9954 dBrHXXRatio2 = 0.0;
9955 } else if (fstate == 2){
9956 BrHXXRatio = (myNPbase->BrHgagaRatio());
9957 dBrHXXRatio1 = BrHXXRatio - 1.0;
9958 dBrHXXRatio2 = 0.0;
9959 } else if (fstate == 3){
9960 BrHXXRatio = (myNPbase->BrHbbRatio());
9961 dBrHXXRatio1 = BrHXXRatio - 1.0;
9962 dBrHXXRatio2 = 0.0;
9963 } else if (fstate == 4){
9964 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9965 dBrHXXRatio1 = BrHXXRatio - 1.0;
9966 dBrHXXRatio2 = 0.0;
9967 } else if (fstate == 5){
9968 BrHXXRatio = (myNPbase->BrHtautauRatio());
9969 dBrHXXRatio1 = BrHXXRatio - 1.0;
9970 dBrHXXRatio2 = 0.0;
9971 } else {
9972 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9973 }
9974
9975 //-- Production x Decay:
9976 if ((this->getModel()).isModelLinearized()){
9977 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9978 } else if((this->getModel()).isModelNPquadratic()){
9979 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9980 } else {
9981 return weight*(muProd)*(BrHXXRatio);
9982 }
9983
9984}
9985
9986// -----------------------------------------------------------------------------
9987
9988STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9989: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9990{
9991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9992 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
9993
9994}
9995
9997{
9998 //-- Production:
9999 double weight = 1.0; //If normalized to the SM
10000 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
10001 double muProd1 = muProd -1.0;
10002 double muProd2 = 0.0;
10003
10004 //-- Decay:
10005 double BrHXXRatio = 1.0;
10006 double dBrHXXRatio1 = 0.0;
10007 double dBrHXXRatio2 = 0.0;
10008 if (fstate==0){
10009 // Use for Cross-section [pb] with no Higgs-boson decay
10010 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10011 } else if (fstate == 1){
10012 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10013 dBrHXXRatio1 = BrHXXRatio - 1.0;
10014 dBrHXXRatio2 = 0.0;
10015 } else if (fstate == 2){
10016 BrHXXRatio = (myNPbase->BrHgagaRatio());
10017 dBrHXXRatio1 = BrHXXRatio - 1.0;
10018 dBrHXXRatio2 = 0.0;
10019 } else if (fstate == 3){
10020 BrHXXRatio = (myNPbase->BrHbbRatio());
10021 dBrHXXRatio1 = BrHXXRatio - 1.0;
10022 dBrHXXRatio2 = 0.0;
10023 } else if (fstate == 4){
10024 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10025 dBrHXXRatio1 = BrHXXRatio - 1.0;
10026 dBrHXXRatio2 = 0.0;
10027 } else if (fstate == 5){
10028 BrHXXRatio = (myNPbase->BrHtautauRatio());
10029 dBrHXXRatio1 = BrHXXRatio - 1.0;
10030 dBrHXXRatio2 = 0.0;
10031 } else {
10032 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10033 }
10034
10035 //-- Production x Decay:
10036 if ((this->getModel()).isModelLinearized()){
10037 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10038 } else if((this->getModel()).isModelNPquadratic()){
10039 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10040 } else {
10041 return weight*(muProd)*(BrHXXRatio);
10042 }
10043
10044}
10045
10046// -----------------------------------------------------------------------------
10047
10048//AG:STXS2024
10049STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10050: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10051{
10052 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10053 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10054
10055}
10056
10058{
10059 //-- Production:
10060 double weight = 1.0; //If normalized to the SM
10062 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10063 double muProd2 = 0.0;
10064
10065 //-- Decay:
10066 double BrHXXRatio = 1.0;
10067 double dBrHXXRatio1 = 0.0;
10068 double dBrHXXRatio2 = 0.0;
10069 if (fstate==0){
10070 // Use for Cross-section [pb] with no Higgs-boson decay
10071 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10072 } else if (fstate == 1){
10073 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10074 dBrHXXRatio1 = BrHXXRatio - 1.0;
10075 dBrHXXRatio2 = 0.0;
10076 } else if (fstate == 2){
10077 BrHXXRatio = (myNPbase->BrHgagaRatio());
10078 dBrHXXRatio1 = BrHXXRatio - 1.0;
10079 dBrHXXRatio2 = 0.0;
10080 } else if (fstate == 3){
10081 BrHXXRatio = (myNPbase->BrHbbRatio());
10082 dBrHXXRatio1 = BrHXXRatio - 1.0;
10083 dBrHXXRatio2 = 0.0;
10084 } else if (fstate == 4){
10085 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10086 dBrHXXRatio1 = BrHXXRatio - 1.0;
10087 dBrHXXRatio2 = 0.0;
10088 } else if (fstate == 5){
10089 BrHXXRatio = (myNPbase->BrHtautauRatio());
10090 dBrHXXRatio1 = BrHXXRatio - 1.0;
10091 dBrHXXRatio2 = 0.0;
10092 } else {
10093 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10094 }
10095
10096 //-- Production x Decay:
10097 if ((this->getModel()).isModelLinearized()){
10098 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10099 } else if((this->getModel()).isModelNPquadratic()){
10100 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10101 } else {
10102 return weight*(muProd)*(BrHXXRatio);
10103 }
10104
10105
10106}
10107
10108// -----------------------------------------------------------------------------
10109
10110STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10111: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10112{
10113 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10114 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10115
10116}
10117
10119{
10120 double BrHXXRatio = 1.0;
10121 if (fstate == 1){
10122 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10123 } else if (fstate == 2){
10124 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10125 } else if (fstate == 3){
10126 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10127 } else if (fstate == 4){
10128 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10129 } else {
10130 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10131 }
10132
10133 if ((this->getModel()).isModelLinearized()) {
10134 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10135 } else {
10136 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10137 }
10138}
10139
10140// -----------------------------------------------------------------------------
10141
10142STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10143: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10144{
10145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10146 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10147
10148}
10149
10151{
10152 double BrHXXRatio = 1.0;
10153 if (fstate == 1){
10154 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10155 } else if (fstate == 2){
10156 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10157 } else if (fstate == 3){
10158 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10159 } else if (fstate == 4){
10160 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10161 } else {
10162 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10163 }
10164
10165 if ((this->getModel()).isModelLinearized()) {
10166 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10167 } else {
10168 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10169 }
10170}
10171
10172// -----------------------------------------------------------------------------
10173
10174//AG:STXS2024
10175STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10176: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10177{
10178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10179 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10180
10181}
10182
10184{
10185 //-- Production:
10186 double weight = 1.0; //If normalized to the SM
10187 //Since adding bins, include partial weigths of SM_predictions
10188 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10189 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10190 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10191 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10192 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10193 double muProd2 = 0.0;
10194
10195 //-- Decay:
10196 double BrHXXRatio = 1.0;
10197 double dBrHXXRatio1 = 0.0;
10198 double dBrHXXRatio2 = 0.0;
10199 if (fstate==0){
10200 // Use for Cross-section [pb] with no Higgs-boson decay
10201 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10202 } else if (fstate == 1){
10203 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10204 dBrHXXRatio1 = BrHXXRatio - 1.0;
10205 dBrHXXRatio2 = 0.0;
10206 } else if (fstate == 2){
10207 BrHXXRatio = (myNPbase->BrHgagaRatio());
10208 dBrHXXRatio1 = BrHXXRatio - 1.0;
10209 dBrHXXRatio2 = 0.0;
10210 } else if (fstate == 3){
10211 BrHXXRatio = (myNPbase->BrHbbRatio());
10212 dBrHXXRatio1 = BrHXXRatio - 1.0;
10213 dBrHXXRatio2 = 0.0;
10214 } else if (fstate == 4){
10215 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10216 dBrHXXRatio1 = BrHXXRatio - 1.0;
10217 dBrHXXRatio2 = 0.0;
10218 } else {
10219 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10220 }
10221
10222 //-- Production x Decay:
10223 if ((this->getModel()).isModelLinearized()){
10224 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10225 } else if((this->getModel()).isModelNPquadratic()){
10226 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10227 } else {
10228 return weight*(muProd)*(BrHXXRatio);
10229 }
10230
10231
10232}
10233
10234// -----------------------------------------------------------------------------
10235
10236//AG:STXS2024
10237STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10238: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10239{
10240 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10241 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10242
10243}
10244
10246{
10247 //-- Production:
10248 double weight = 1.0; //If normalized to the SM
10249 //Since adding bins, include partial weigths of SM_predictions
10250 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10251 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10253 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10254 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10255 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10256 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10257 double muProd2 = 0.0;
10258
10259 //-- Decay:
10260 double BrHXXRatio = 1.0;
10261 double dBrHXXRatio1 = 0.0;
10262 double dBrHXXRatio2 = 0.0;
10263 if (fstate==0){
10264 // Use for Cross-section [pb] with no Higgs-boson decay
10265 weight = 1.0 ;
10266 } else if (fstate == 1){
10267 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10268 dBrHXXRatio1 = BrHXXRatio - 1.0;
10269 dBrHXXRatio2 = 0.0;
10270 } else if (fstate == 2){
10271 BrHXXRatio = (myNPbase->BrHgagaRatio());
10272 dBrHXXRatio1 = BrHXXRatio - 1.0;
10273 dBrHXXRatio2 = 0.0;
10274 } else if (fstate == 3){
10275 BrHXXRatio = (myNPbase->BrHbbRatio());
10276 dBrHXXRatio1 = BrHXXRatio - 1.0;
10277 dBrHXXRatio2 = 0.0;
10278 } else if (fstate == 4){
10279 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10280 dBrHXXRatio1 = BrHXXRatio - 1.0;
10281 dBrHXXRatio2 = 0.0;
10282 } else {
10283 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10284 }
10285
10286 //-- Production x Decay:
10287 if ((this->getModel()).isModelLinearized()){
10288 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10289 } else if((this->getModel()).isModelNPquadratic()){
10290 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10291 } else {
10292 return weight*(muProd)*(BrHXXRatio);
10293 }
10294
10295
10296}
10297
10298// -----------------------------------------------------------------------------
10299
10300//AG:STXS2024
10301STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10302: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10303{
10304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10305 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10306
10307}
10308
10310{
10311 //-- Production:
10312 double weight = 1.0; //If normalized to the SM
10313 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10314 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10315 double muProd2 = 0.0;
10316
10317 //-- Decay:
10318 double BrHXXRatio = 1.0;
10319 double dBrHXXRatio1 = 0.0;
10320 double dBrHXXRatio2 = 0.0;
10321 if (fstate==0){
10322 // Use for Cross-section [pb] with no Higgs-boson decay
10323 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10324 } else if (fstate == 1){
10325 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10326 dBrHXXRatio1 = BrHXXRatio - 1.0;
10327 dBrHXXRatio2 = 0.0;
10328 } else if (fstate == 2){
10329 BrHXXRatio = (myNPbase->BrHgagaRatio());
10330 dBrHXXRatio1 = BrHXXRatio - 1.0;
10331 dBrHXXRatio2 = 0.0;
10332 } else if (fstate == 3){
10333 BrHXXRatio = (myNPbase->BrHbbRatio());
10334 dBrHXXRatio1 = BrHXXRatio - 1.0;
10335 dBrHXXRatio2 = 0.0;
10336 } else if (fstate == 4){
10337 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10338 dBrHXXRatio1 = BrHXXRatio - 1.0;
10339 dBrHXXRatio2 = 0.0;
10340 } else {
10341 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10342 }
10343
10344 //-- Production x Decay:
10345 if ((this->getModel()).isModelLinearized()){
10346 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10347 } else if((this->getModel()).isModelNPquadratic()){
10348 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10349 } else {
10350 return weight*(muProd)*(BrHXXRatio);
10351 }
10352
10353
10354}
10355
10356// -----------------------------------------------------------------------------
10357
10358//AG:STXS2024
10359STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10360: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10361{
10362 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10363 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10364
10365}
10366
10368{
10369 //-- Production:
10370 double weight = 1.0; //If normalized to the SM
10371 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10372 double muProd1 = muProd-1.0 ;
10373 double muProd2 = 0.0;
10374
10375 //-- Decay:
10376 double BrHXXRatio = 1.0;
10377 double dBrHXXRatio1 = 0.0;
10378 double dBrHXXRatio2 = 0.0;
10379 if (fstate==0){
10380 // Use for Cross-section [pb] with no Higgs-boson decay
10381 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10382 } else if (fstate == 1){
10383 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10384 dBrHXXRatio1 = BrHXXRatio - 1.0;
10385 dBrHXXRatio2 = 0.0;
10386 } else if (fstate == 2){
10387 BrHXXRatio = (myNPbase->BrHgagaRatio());
10388 dBrHXXRatio1 = BrHXXRatio - 1.0;
10389 dBrHXXRatio2 = 0.0;
10390 } else if (fstate == 3){
10391 BrHXXRatio = (myNPbase->BrHbbRatio());
10392 dBrHXXRatio1 = BrHXXRatio - 1.0;
10393 dBrHXXRatio2 = 0.0;
10394 } else if (fstate == 4){
10395 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10396 dBrHXXRatio1 = BrHXXRatio - 1.0;
10397 dBrHXXRatio2 = 0.0;
10398 } else {
10399 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10400 }
10401
10402 //-- Production x Decay:
10403 if ((this->getModel()).isModelLinearized()){
10404 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10405 } else if((this->getModel()).isModelNPquadratic()){
10406 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10407 } else {
10408 return weight*(muProd)*(BrHXXRatio);
10409 }
10410
10411
10412}
10413
10414
10415// -----------------------------------------------------------------------------
10416
10417STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10418: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10419{
10420 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10421 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10422
10423}
10424
10426{
10427 double BrHXXRatio = 1.0;
10428 if (fstate == 1){
10429 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10430 } else if (fstate == 2){
10431 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10432 } else if (fstate == 3){
10433 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10434 } else if (fstate == 4){
10435 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10436 } else {
10437 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10438 }
10439
10440 if ((this->getModel()).isModelLinearized()) {
10441 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10442 } else {
10443 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10444 }
10445}
10446
10447// -----------------------------------------------------------------------------
10448
10449//AG:STXS2024
10450STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10451: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10452{
10453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10454 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10455
10456}
10457
10459{
10460 //-- Production:
10461 double weight = 1.0; //If normalized to the SM
10462 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10463 double muProd1 = muProd -1.0;
10464 double muProd2 = 0.0;
10465
10466 //-- Decay:
10467 double BrHXXRatio = 1.0;
10468 double dBrHXXRatio1 = 0.0;
10469 double dBrHXXRatio2 = 0.0;
10470 if (fstate==0){
10471 // Use for Cross-section [pb] with no Higgs-boson decay
10472 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10473 } else if (fstate == 1){
10474 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10475 dBrHXXRatio1 = BrHXXRatio - 1.0;
10476 dBrHXXRatio2 = 0.0;
10477 } else if (fstate == 2){
10478 BrHXXRatio = (myNPbase->BrHgagaRatio());
10479 dBrHXXRatio1 = BrHXXRatio - 1.0;
10480 dBrHXXRatio2 = 0.0;
10481 } else if (fstate == 3){
10482 BrHXXRatio = (myNPbase->BrHbbRatio());
10483 dBrHXXRatio1 = BrHXXRatio - 1.0;
10484 dBrHXXRatio2 = 0.0;
10485 } else if (fstate == 4){
10486 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10487 dBrHXXRatio1 = BrHXXRatio - 1.0;
10488 dBrHXXRatio2 = 0.0;
10489 } else {
10490 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10491 }
10492
10493 //-- Production x Decay:
10494 if ((this->getModel()).isModelLinearized()){
10495 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10496 } else if((this->getModel()).isModelNPquadratic()){
10497 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10498 } else {
10499 return weight*(muProd)*(BrHXXRatio);
10500 }
10501
10502
10503}
10504
10505// -----------------------------------------------------------------------------
10506
10507//AG:STXS2024
10508STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10509: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10510{
10511 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10512 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10513
10514}
10515
10517{
10518 //-- Production:
10519 double weight = 1.0; //If normalized to the SM
10521 double muProd1 = muProd -1.0;
10522 double muProd2 = 0.0;
10523
10524 //-- Decay:
10525 double BrHXXRatio = 1.0;
10526 double dBrHXXRatio1 = 0.0;
10527 double dBrHXXRatio2 = 0.0;
10528 if (fstate==0){
10529 // Use for Cross-section [pb] with no Higgs-boson decay
10530 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10531 } else if (fstate == 1){
10532 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10533 dBrHXXRatio1 = BrHXXRatio - 1.0;
10534 dBrHXXRatio2 = 0.0;
10535 } else if (fstate == 2){
10536 BrHXXRatio = (myNPbase->BrHgagaRatio());
10537 dBrHXXRatio1 = BrHXXRatio - 1.0;
10538 dBrHXXRatio2 = 0.0;
10539 } else if (fstate == 3){
10540 BrHXXRatio = (myNPbase->BrHbbRatio());
10541 dBrHXXRatio1 = BrHXXRatio - 1.0;
10542 dBrHXXRatio2 = 0.0;
10543 } else if (fstate == 4){
10544 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10545 dBrHXXRatio1 = BrHXXRatio - 1.0;
10546 dBrHXXRatio2 = 0.0;
10547 } else {
10548 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10549 }
10550
10551 //-- Production x Decay:
10552 if ((this->getModel()).isModelLinearized()){
10553 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10554 } else if((this->getModel()).isModelNPquadratic()){
10555 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10556 } else {
10557 return weight*(muProd)*(BrHXXRatio);
10558 }
10559
10560}
10561
10562// -----------------------------------------------------------------------------
10563
10564STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10565: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10566{
10567 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10568 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10569
10570}
10571
10573{
10574 double BrHXXRatio = 1.0;
10575 if (fstate == 1){
10576 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10577 } else if (fstate == 2){
10578 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10579 } else if (fstate == 3){
10580 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10581 } else if (fstate == 4){
10582 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10583 } else {
10584 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10585 }
10586
10587 if ((this->getModel()).isModelLinearized()) {
10588 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10589 } else {
10590 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10591 }
10592}
10593
10594// -----------------------------------------------------------------------------
10595
10596STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10597: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10598{
10599 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10600 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10601
10602}
10603
10605{
10606 double BrHXXRatio = 1.0;
10607 if (fstate == 1){
10608 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10609 } else if (fstate == 2){
10610 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10611 } else if (fstate == 3){
10612 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10613 } else if (fstate == 4){
10614 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10615 } else {
10616 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10617 }
10618
10619 if ((this->getModel()).isModelLinearized()) {
10620 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10621 } else {
10622 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10623 }
10624}
10625
10626
10627// -----------------------------------------------------------------------------
10628
10629//AG:STXS2024
10630STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10631: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10632{
10633 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10634 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10635
10636}
10637
10639{
10640 //-- Production:
10641 double weight = 1.0; //If normalized to the SM
10642 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10643 double muProd1 = muProd -1.0;
10644 double muProd2 = 0.0;
10645
10646 //-- Decay:
10647 double BrHXXRatio = 1.0;
10648 double dBrHXXRatio1 = 0.0;
10649 double dBrHXXRatio2 = 0.0;
10650 if (fstate==0){
10651 // Use for Cross-section [pb] with no Higgs-boson decay
10652 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10653 } else if (fstate == 1){
10654 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10655 dBrHXXRatio1 = BrHXXRatio - 1.0;
10656 dBrHXXRatio2 = 0.0;
10657 } else if (fstate == 2){
10658 BrHXXRatio = (myNPbase->BrHgagaRatio());
10659 dBrHXXRatio1 = BrHXXRatio - 1.0;
10660 dBrHXXRatio2 = 0.0;
10661 } else if (fstate == 3){
10662 BrHXXRatio = (myNPbase->BrHbbRatio());
10663 dBrHXXRatio1 = BrHXXRatio - 1.0;
10664 dBrHXXRatio2 = 0.0;
10665 } else if (fstate == 4){
10666 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10667 dBrHXXRatio1 = BrHXXRatio - 1.0;
10668 dBrHXXRatio2 = 0.0;
10669 } else {
10670 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10671 }
10672
10673 //-- Production x Decay:
10674 if ((this->getModel()).isModelLinearized()){
10675 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10676 } else if((this->getModel()).isModelNPquadratic()){
10677 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10678 } else {
10679 return weight*(muProd)*(BrHXXRatio);
10680 }
10681
10682}
10683
10684// -----------------------------------------------------------------------------
10685
10686//AG:STXS2024
10687STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10688: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10689{
10690 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10691 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10692
10693}
10694
10696{
10697 //-- Production:
10698 double weight = 1.0; //If normalized to the SM
10699 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10700 double muProd1 = muProd -1.0;
10701 double muProd2 = 0.0;
10702
10703 //-- Decay:
10704 double BrHXXRatio = 1.0;
10705 double dBrHXXRatio1 = 0.0;
10706 double dBrHXXRatio2 = 0.0;
10707 if (fstate==0){
10708 // Use for Cross-section [pb] with no Higgs-boson decay
10709 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10710 } else if (fstate == 1){
10711 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10712 dBrHXXRatio1 = BrHXXRatio - 1.0;
10713 dBrHXXRatio2 = 0.0;
10714 } else if (fstate == 2){
10715 BrHXXRatio = (myNPbase->BrHgagaRatio());
10716 dBrHXXRatio1 = BrHXXRatio - 1.0;
10717 dBrHXXRatio2 = 0.0;
10718 } else if (fstate == 3){
10719 BrHXXRatio = (myNPbase->BrHbbRatio());
10720 dBrHXXRatio1 = BrHXXRatio - 1.0;
10721 dBrHXXRatio2 = 0.0;
10722 } else if (fstate == 4){
10723 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10724 dBrHXXRatio1 = BrHXXRatio - 1.0;
10725 dBrHXXRatio2 = 0.0;
10726 } else {
10727 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10728 }
10729
10730 //-- Production x Decay:
10731 if ((this->getModel()).isModelLinearized()){
10732 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10733 } else if((this->getModel()).isModelNPquadratic()){
10734 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10735 } else {
10736 return weight*(muProd)*(BrHXXRatio);
10737 }
10738
10739}
10740
10741// -----------------------------------------------------------------------------
10742
10743//AG:STXS2024
10744STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10745: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10746{
10747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10748 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10749
10750}
10751
10753{
10754 //-- Production:
10755 double weight = 1.0; //If normalized to the SM
10756 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10757 double muProd1 = muProd -1.0;
10758 double muProd2 = 0.0;
10759
10760 //-- Decay:
10761 double BrHXXRatio = 1.0;
10762 double dBrHXXRatio1 = 0.0;
10763 double dBrHXXRatio2 = 0.0;
10764 if (fstate==0){
10765 // Use for Cross-section [pb] with no Higgs-boson decay
10766 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10767 } else if (fstate == 1){
10768 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10769 dBrHXXRatio1 = BrHXXRatio - 1.0;
10770 dBrHXXRatio2 = 0.0;
10771 } else if (fstate == 2){
10772 BrHXXRatio = (myNPbase->BrHgagaRatio());
10773 dBrHXXRatio1 = BrHXXRatio - 1.0;
10774 dBrHXXRatio2 = 0.0;
10775 } else if (fstate == 3){
10776 BrHXXRatio = (myNPbase->BrHbbRatio());
10777 dBrHXXRatio1 = BrHXXRatio - 1.0;
10778 dBrHXXRatio2 = 0.0;
10779 } else if (fstate == 4){
10780 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10781 dBrHXXRatio1 = BrHXXRatio - 1.0;
10782 dBrHXXRatio2 = 0.0;
10783 } else {
10784 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10785 }
10786
10787 //-- Production x Decay:
10788 if ((this->getModel()).isModelLinearized()){
10789 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10790 } else if((this->getModel()).isModelNPquadratic()){
10791 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10792 } else {
10793 return weight*(muProd)*(BrHXXRatio);
10794 }
10795
10796
10797}
10798
10799// -----------------------------------------------------------------------------
10800
10801//AG:STXS2024
10802STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10803: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10804{
10805 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10806 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10807
10808}
10809
10811{
10812 //-- Production:
10813 double weight = 1.0; //If normalized to the SM
10814 //Since adding bins, include partial weigths of SM_predictions
10815 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10816 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10818 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10819 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10820 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10821 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10822 double muProd2 = 0.0;
10823
10824 //-- Decay:
10825 double BrHXXRatio = 1.0;
10826 double dBrHXXRatio1 = 0.0;
10827 double dBrHXXRatio2 = 0.0;
10828 if (fstate==0){
10829 weight = 1.0 ;
10830 } else if (fstate == 1){
10831 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10832 dBrHXXRatio1 = BrHXXRatio - 1.0;
10833 dBrHXXRatio2 = 0.0;
10834 } else if (fstate == 2){
10835 BrHXXRatio = (myNPbase->BrHgagaRatio());
10836 dBrHXXRatio1 = BrHXXRatio - 1.0;
10837 dBrHXXRatio2 = 0.0;
10838 } else if (fstate == 3){
10839 BrHXXRatio = (myNPbase->BrHbbRatio());
10840 dBrHXXRatio1 = BrHXXRatio - 1.0;
10841 dBrHXXRatio2 = 0.0;
10842 } else if (fstate == 4){
10843 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10844 dBrHXXRatio1 = BrHXXRatio - 1.0;
10845 dBrHXXRatio2 = 0.0;
10846 } else {
10847 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10848 }
10849
10850 //-- Production x Decay:
10851 if ((this->getModel()).isModelLinearized()){
10852 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10853 } else if((this->getModel()).isModelNPquadratic()){
10854 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10855 } else {
10856 return weight*(muProd)*(BrHXXRatio);
10857 }
10858
10859
10860}
10861
10862// -----------------------------------------------------------------------------
10863
10864//AG:STXS2024
10865STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10866: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10867{
10868 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10869 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10870
10871}
10872
10874{
10875 //-- Production:
10876 double weight = 1.0; //If normalized to the SM
10877 //Since adding bins, include partial weigths of SM_predictions
10878 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10879 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10888 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10889 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10890 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10892 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10893 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10894 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10896 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10897 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10898 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10899 double muProd2 = 0.0;
10900
10901 //-- Decay:
10902 double BrHXXRatio = 1.0;
10903 double dBrHXXRatio1 = 0.0;
10904 double dBrHXXRatio2 = 0.0;
10905 if (fstate==0){
10906 weight = 1.0;
10907 } else if (fstate == 1){
10908 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10909 dBrHXXRatio1 = BrHXXRatio - 1.0;
10910 dBrHXXRatio2 = 0.0;
10911 } else if (fstate == 2){
10912 BrHXXRatio = (myNPbase->BrHgagaRatio());
10913 dBrHXXRatio1 = BrHXXRatio - 1.0;
10914 dBrHXXRatio2 = 0.0;
10915 } else if (fstate == 3){
10916 BrHXXRatio = (myNPbase->BrHbbRatio());
10917 dBrHXXRatio1 = BrHXXRatio - 1.0;
10918 dBrHXXRatio2 = 0.0;
10919 } else if (fstate == 4){
10920 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10921 dBrHXXRatio1 = BrHXXRatio - 1.0;
10922 dBrHXXRatio2 = 0.0;
10923 } else if (fstate == 5){
10924 BrHXXRatio = (myNPbase->BrHtautauRatio());
10925 dBrHXXRatio1 = BrHXXRatio - 1.0;
10926 dBrHXXRatio2 = 0.0;
10927 } else if (fstate == 6){
10928 BrHXXRatio = (myNPbase->BrHWWRatio());
10929 dBrHXXRatio1 = BrHXXRatio - 1.0;
10930 dBrHXXRatio2 = 0.0;
10931 } else if (fstate == 7){
10932 BrHXXRatio = (myNPbase->BrHZZRatio());
10933 dBrHXXRatio1 = BrHXXRatio - 1.0;
10934 dBrHXXRatio2 = 0.0;
10935 } else {
10936 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10937 }
10938
10939 //-- Production x Decay:
10940 if ((this->getModel()).isModelLinearized()){
10941 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10942 } else if((this->getModel()).isModelNPquadratic()){
10943 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10944 } else {
10945 return weight*(muProd)*(BrHXXRatio);
10946 }
10947
10948
10949}
10950
10951// -----------------------------------------------------------------------------
10952
10953//AG:STXS2024
10954STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10955: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10956{
10957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10958 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
10959
10960}
10961
10963{
10964 //-- Production:
10965 double weight = 1.0; //If normalized to the SM
10966 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
10967 double muProd1 = muProd -1.0;
10968 double muProd2 = 0.0;
10969
10970 //-- Decay:
10971 double BrHXXRatio = 1.0;
10972 double dBrHXXRatio1 = 0.0;
10973 double dBrHXXRatio2 = 0.0;
10974 if (fstate==0){
10975 // Use for Cross-section [pb] with no Higgs-boson decay
10976 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10977 } else if (fstate == 1){
10978 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10979 dBrHXXRatio1 = BrHXXRatio - 1.0;
10980 dBrHXXRatio2 = 0.0;
10981 } else if (fstate == 2){
10982 BrHXXRatio = (myNPbase->BrHgagaRatio());
10983 dBrHXXRatio1 = BrHXXRatio - 1.0;
10984 dBrHXXRatio2 = 0.0;
10985 } else if (fstate == 3){
10986 BrHXXRatio = (myNPbase->BrHbbRatio());
10987 dBrHXXRatio1 = BrHXXRatio - 1.0;
10988 dBrHXXRatio2 = 0.0;
10989 } else if (fstate == 4){
10990 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10991 dBrHXXRatio1 = BrHXXRatio - 1.0;
10992 dBrHXXRatio2 = 0.0;
10993 } else {
10994 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
10995 }
10996
10997 //-- Production x Decay:
10998 if ((this->getModel()).isModelLinearized()){
10999 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11000 } else if((this->getModel()).isModelNPquadratic()){
11001 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11002 } else {
11003 return weight*(muProd)*(BrHXXRatio);
11004 }
11005
11006
11007}
11008
11009// -----------------------------------------------------------------------------
11010
11011//AG:STXS2024
11012STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11013: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11014{
11015 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11016 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
11017
11018}
11019
11021{
11022 //-- Production:
11023 double weight = 1.0; //If normalized to the SM
11024 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
11025 double muProd1 = muProd -1.0;
11026 double muProd2 = 0.0;
11027
11028 //-- Decay:
11029 double BrHXXRatio = 1.0;
11030 double dBrHXXRatio1 = 0.0;
11031 double dBrHXXRatio2 = 0.0;
11032 if (fstate==0){
11033 // Use for Cross-section [pb] with no Higgs-boson decay
11034 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11035 } else if (fstate == 1){
11036 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11037 dBrHXXRatio1 = BrHXXRatio - 1.0;
11038 dBrHXXRatio2 = 0.0;
11039 } else if (fstate == 2){
11040 BrHXXRatio = (myNPbase->BrHgagaRatio());
11041 dBrHXXRatio1 = BrHXXRatio - 1.0;
11042 dBrHXXRatio2 = 0.0;
11043 } else if (fstate == 3){
11044 BrHXXRatio = (myNPbase->BrHbbRatio());
11045 dBrHXXRatio1 = BrHXXRatio - 1.0;
11046 dBrHXXRatio2 = 0.0;
11047 } else if (fstate == 4){
11048 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11049 dBrHXXRatio1 = BrHXXRatio - 1.0;
11050 dBrHXXRatio2 = 0.0;
11051 } else {
11052 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
11053 }
11054
11055 //-- Production x Decay:
11056 if ((this->getModel()).isModelLinearized()){
11057 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11058 } else if((this->getModel()).isModelNPquadratic()){
11059 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11060 } else {
11061 return weight*(muProd)*(BrHXXRatio);
11062 }
11063
11064}
11065
11066// -----------------------------------------------------------------------------
11067
11068//AG:STXS2024
11069STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11070: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11071{
11072 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11073 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
11074
11075}
11076
11078{
11079 //-- Production:
11080 double weight = 1.0; //If normalized to the SM
11081 //Since adding bins, include partial weigths of SM_predictions
11082 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11083 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
11084 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
11085 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
11086 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
11087 double muProd2 = 0.0;
11088
11089 //-- Decay:
11090 double BrHXXRatio = 1.0;
11091 double dBrHXXRatio1 = 0.0;
11092 double dBrHXXRatio2 = 0.0;
11093 if (fstate==0){
11094 // Use for Cross-section [pb] with no Higgs-boson decay
11095 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11096 } else if (fstate == 1){
11097 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11098 dBrHXXRatio1 = BrHXXRatio - 1.0;
11099 dBrHXXRatio2 = 0.0;
11100 } else if (fstate == 2){
11101 BrHXXRatio = (myNPbase->BrHgagaRatio());
11102 dBrHXXRatio1 = BrHXXRatio - 1.0;
11103 dBrHXXRatio2 = 0.0;
11104 } else if (fstate == 3){
11105 BrHXXRatio = (myNPbase->BrHbbRatio());
11106 dBrHXXRatio1 = BrHXXRatio - 1.0;
11107 dBrHXXRatio2 = 0.0;
11108 } else if (fstate == 4){
11109 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11110 dBrHXXRatio1 = BrHXXRatio - 1.0;
11111 dBrHXXRatio2 = 0.0;
11112 } else {
11113 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
11114 }
11115
11116 //-- Production x Decay:
11117 if ((this->getModel()).isModelLinearized()){
11118 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11119 } else if((this->getModel()).isModelNPquadratic()){
11120 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11121 } else {
11122 return weight*(muProd)*(BrHXXRatio);
11123 }
11124
11125}
11126
11127// -----------------------------------------------------------------------------
11128
11129//AG:STXS2024
11130STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11131: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11132{
11133 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11134 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
11135
11136}
11137
11139{
11140 //-- Production:
11141 double weight = 1.0; //If normalized to the SM
11142 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
11143 double muProd1 = muProd -1.0;
11144 double muProd2 = 0.0;
11145
11146 //-- Decay:
11147 double BrHXXRatio = 1.0;
11148 double dBrHXXRatio1 = 0.0;
11149 double dBrHXXRatio2 = 0.0;
11150 if (fstate==0){
11151 // Use for Cross-section [pb] with no Higgs-boson decay
11152 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11153 } else if (fstate == 1){
11154 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11155 dBrHXXRatio1 = BrHXXRatio - 1.0;
11156 dBrHXXRatio2 = 0.0;
11157 } else if (fstate == 2){
11158 BrHXXRatio = (myNPbase->BrHgagaRatio());
11159 dBrHXXRatio1 = BrHXXRatio - 1.0;
11160 dBrHXXRatio2 = 0.0;
11161 } else if (fstate == 3){
11162 BrHXXRatio = (myNPbase->BrHbbRatio());
11163 dBrHXXRatio1 = BrHXXRatio - 1.0;
11164 dBrHXXRatio2 = 0.0;
11165 } else if (fstate == 4){
11166 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11167 dBrHXXRatio1 = BrHXXRatio - 1.0;
11168 dBrHXXRatio2 = 0.0;
11169 } else {
11170 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
11171 }
11172
11173 //-- Production x Decay:
11174 if ((this->getModel()).isModelLinearized()){
11175 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11176 } else if((this->getModel()).isModelNPquadratic()){
11177 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11178 } else {
11179 return weight*(muProd)*(BrHXXRatio);
11180 }
11181
11182}
11183
11184// -----------------------------------------------------------------------------
11185
11186//AG:STXS2024
11187STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11188: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11189{
11190 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11191 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
11192
11193}
11194
11196{
11197 //-- Production:
11198 double weight = 1.0; //If normalized to the SM
11199 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
11200 double muProd1 = muProd -1.0;
11201 double muProd2 = 0.0;
11202
11203 //-- Decay:
11204 double BrHXXRatio = 1.0;
11205 double dBrHXXRatio1 = 0.0;
11206 double dBrHXXRatio2 = 0.0;
11207 if (fstate==0){
11208 // Use for Cross-section [pb] with no Higgs-boson decay
11209 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11210 } else if (fstate == 1){
11211 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11212 dBrHXXRatio1 = BrHXXRatio - 1.0;
11213 dBrHXXRatio2 = 0.0;
11214 } else if (fstate == 2){
11215 BrHXXRatio = (myNPbase->BrHgagaRatio());
11216 dBrHXXRatio1 = BrHXXRatio - 1.0;
11217 dBrHXXRatio2 = 0.0;
11218 } else if (fstate == 3){
11219 BrHXXRatio = (myNPbase->BrHbbRatio());
11220 dBrHXXRatio1 = BrHXXRatio - 1.0;
11221 dBrHXXRatio2 = 0.0;
11222 } else if (fstate == 4){
11223 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11224 dBrHXXRatio1 = BrHXXRatio - 1.0;
11225 dBrHXXRatio2 = 0.0;
11226 } else {
11227 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
11228 }
11229
11230 //-- Production x Decay:
11231 if ((this->getModel()).isModelLinearized()){
11232 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11233 } else if((this->getModel()).isModelNPquadratic()){
11234 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11235 } else {
11236 return weight*(muProd)*(BrHXXRatio);
11237 }
11238
11239}
11240
11241// -----------------------------------------------------------------------------
11242
11243STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11244: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11245{
11246 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11247 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
11248
11249}
11250
11252{
11253 //-- Production:
11254 double weight = 1.0; //If normalized to the SM
11255 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
11256 double muProd1 = muProd -1.0;
11257 double muProd2 = 0.0;
11258
11259 //-- Decay:
11260 double BrHXXRatio = 1.0;
11261 double dBrHXXRatio1 = 0.0;
11262 double dBrHXXRatio2 = 0.0;
11263 if (fstate==0){
11264 // Use for Cross-section [pb] with no Higgs-boson decay
11265 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11266 } else if (fstate == 1){
11267 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11268 dBrHXXRatio1 = BrHXXRatio - 1.0;
11269 dBrHXXRatio2 = 0.0;
11270 } else if (fstate == 2){
11271 BrHXXRatio = (myNPbase->BrHgagaRatio());
11272 dBrHXXRatio1 = BrHXXRatio - 1.0;
11273 dBrHXXRatio2 = 0.0;
11274 } else if (fstate == 3){
11275 BrHXXRatio = (myNPbase->BrHbbRatio());
11276 dBrHXXRatio1 = BrHXXRatio - 1.0;
11277 dBrHXXRatio2 = 0.0;
11278 } else if (fstate == 4){
11279 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11280 dBrHXXRatio1 = BrHXXRatio - 1.0;
11281 dBrHXXRatio2 = 0.0;
11282 } else {
11283 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
11284 }
11285
11286 //-- Production x Decay:
11287 if ((this->getModel()).isModelLinearized()){
11288 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11289 } else if((this->getModel()).isModelNPquadratic()){
11290 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11291 } else {
11292 return weight*(muProd)*(BrHXXRatio);
11293 }
11294
11295
11296}
11297
11298// -----------------------------------------------------------------------------
11299
11300//AG:STXS2024
11301STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11302: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11303{
11304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11305 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11306
11307}
11308
11310{
11311 //-- Production:
11312 double weight = 1.0; //If normalized to the SM
11313 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11314 double muProd1 = muProd -1.0;
11315 double muProd2 = 0.0;
11316
11317 //-- Decay:
11318 double BrHXXRatio = 1.0;
11319 double dBrHXXRatio1 = 0.0;
11320 double dBrHXXRatio2 = 0.0;
11321 if (fstate==0){
11322 // Use for Cross-section [pb] with no Higgs-boson decay
11323 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11324 } else if (fstate == 1){
11325 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11326 dBrHXXRatio1 = BrHXXRatio - 1.0;
11327 dBrHXXRatio2 = 0.0;
11328 } else if (fstate == 2){
11329 BrHXXRatio = (myNPbase->BrHgagaRatio());
11330 dBrHXXRatio1 = BrHXXRatio - 1.0;
11331 dBrHXXRatio2 = 0.0;
11332 } else if (fstate == 3){
11333 BrHXXRatio = (myNPbase->BrHbbRatio());
11334 dBrHXXRatio1 = BrHXXRatio - 1.0;
11335 dBrHXXRatio2 = 0.0;
11336 } else if (fstate == 4){
11337 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11338 dBrHXXRatio1 = BrHXXRatio - 1.0;
11339 dBrHXXRatio2 = 0.0;
11340 } else if (fstate == 5){
11341 BrHXXRatio = (myNPbase->BrHtautauRatio());
11342 dBrHXXRatio1 = BrHXXRatio - 1.0;
11343 dBrHXXRatio2 = 0.0;
11344 } else {
11345 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11346 }
11347
11348 //-- Production x Decay:
11349 if ((this->getModel()).isModelLinearized()){
11350 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11351 } else if((this->getModel()).isModelNPquadratic()){
11352 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11353 } else {
11354 return weight*(muProd)*(BrHXXRatio);
11355 }
11356
11357}
11358// -----------------------------------------------------------------------------
11359
11360//AG:STXS2024
11361STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11362: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11363{
11364 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11365 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11366
11367}
11368
11370{
11371 //-- Production:
11372 double weight = 1.0; //If normalized to the SM
11373 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11374 double muProd1 = muProd -1.0;
11375 double muProd2 = 0.0;
11376
11377 //-- Decay:
11378 double BrHXXRatio = 1.0;
11379 double dBrHXXRatio1 = 0.0;
11380 double dBrHXXRatio2 = 0.0;
11381 if (fstate==0){
11382 // Use for Cross-section [pb] with no Higgs-boson decay
11383 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11384 } else if (fstate == 1){
11385 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11386 dBrHXXRatio1 = BrHXXRatio - 1.0;
11387 dBrHXXRatio2 = 0.0;
11388 } else if (fstate == 2){
11389 BrHXXRatio = (myNPbase->BrHgagaRatio());
11390 dBrHXXRatio1 = BrHXXRatio - 1.0;
11391 dBrHXXRatio2 = 0.0;
11392 } else if (fstate == 3){
11393 BrHXXRatio = (myNPbase->BrHbbRatio());
11394 dBrHXXRatio1 = BrHXXRatio - 1.0;
11395 dBrHXXRatio2 = 0.0;
11396 } else if (fstate == 4){
11397 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11398 dBrHXXRatio1 = BrHXXRatio - 1.0;
11399 dBrHXXRatio2 = 0.0;
11400 } else if (fstate == 5){
11401 BrHXXRatio = (myNPbase->BrHtautauRatio());
11402 dBrHXXRatio1 = BrHXXRatio - 1.0;
11403 dBrHXXRatio2 = 0.0;
11404 } else {
11405 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11406 }
11407
11408 //-- Production x Decay:
11409 if ((this->getModel()).isModelLinearized()){
11410 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11411 } else if((this->getModel()).isModelNPquadratic()){
11412 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11413 } else {
11414 return weight*(muProd)*(BrHXXRatio);
11415 }
11416
11417}
11418
11419// -----------------------------------------------------------------------------
11420
11421//AG:STXS2024
11422STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11423: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11424{
11425 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11426 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11427
11428}
11429
11431{
11432 //-- Production:
11433 double weight = 1.0; //If normalized to the SM
11434 //Since adding bins, include partial weigths of SM_predictions
11435 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11436 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11437 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11438 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11439 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11440 double muProd2 = 0.0;
11441
11442 //-- Decay:
11443 double BrHXXRatio = 1.0;
11444 double dBrHXXRatio1 = 0.0;
11445 double dBrHXXRatio2 = 0.0;
11446 if (fstate==0){
11447 // Use for Cross-section [pb] with no Higgs-boson decay
11448 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11449 } else if (fstate == 1){
11450 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11451 dBrHXXRatio1 = BrHXXRatio - 1.0;
11452 dBrHXXRatio2 = 0.0;
11453 } else if (fstate == 2){
11454 BrHXXRatio = (myNPbase->BrHgagaRatio());
11455 dBrHXXRatio1 = BrHXXRatio - 1.0;
11456 dBrHXXRatio2 = 0.0;
11457 } else if (fstate == 3){
11458 BrHXXRatio = (myNPbase->BrHbbRatio());
11459 dBrHXXRatio1 = BrHXXRatio - 1.0;
11460 dBrHXXRatio2 = 0.0;
11461 } else if (fstate == 4){
11462 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11463 dBrHXXRatio1 = BrHXXRatio - 1.0;
11464 dBrHXXRatio2 = 0.0;
11465 } else if (fstate == 5){
11466 BrHXXRatio = (myNPbase->BrHtautauRatio());
11467 dBrHXXRatio1 = BrHXXRatio - 1.0;
11468 dBrHXXRatio2 = 0.0;
11469 } else {
11470 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11471 }
11472
11473 //-- Production x Decay:
11474 if ((this->getModel()).isModelLinearized()){
11475 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11476 } else if((this->getModel()).isModelNPquadratic()){
11477 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11478 } else {
11479 return weight*(muProd)*(BrHXXRatio);
11480 }
11481
11482}
11483
11484// -----------------------------------------------------------------------------
11485
11486//AG:STXS2024
11487STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11488: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11489{
11490 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11491 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11492
11493}
11494
11496{
11497 //-- Production:
11498 double weight = 1.0; //If normalized to the SM
11499 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11500 //Since adding bins, include partial weigths (SM_predictions)
11501 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11506 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11507 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11508 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11509 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11510 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11511 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11512 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11513 double muProd2 = 0.0;
11514
11515 //-- Decay:
11516 double BrHXXRatio = 1.0;
11517 double dBrHXXRatio1 = 0.0;
11518 double dBrHXXRatio2 = 0.0;
11519 if (fstate==0){
11520 weight = 1.0;
11521 } else if (fstate == 1){
11522 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11523 dBrHXXRatio1 = BrHXXRatio - 1.0;
11524 dBrHXXRatio2 = 0.0;
11525 } else if (fstate == 2){
11526 BrHXXRatio = (myNPbase->BrHgagaRatio());
11527 dBrHXXRatio1 = BrHXXRatio - 1.0;
11528 dBrHXXRatio2 = 0.0;
11529 } else if (fstate == 3){
11530 BrHXXRatio = (myNPbase->BrHbbRatio());
11531 dBrHXXRatio1 = BrHXXRatio - 1.0;
11532 dBrHXXRatio2 = 0.0;
11533 } else if (fstate == 4){
11534 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11535 dBrHXXRatio1 = BrHXXRatio - 1.0;
11536 dBrHXXRatio2 = 0.0;
11537 } else if (fstate == 5){
11538 BrHXXRatio = (myNPbase->BrHtautauRatio());
11539 dBrHXXRatio1 = BrHXXRatio - 1.0;
11540 dBrHXXRatio2 = 0.0;
11541 } else if (fstate == 6){
11542 BrHXXRatio = (myNPbase->BrHWWRatio());
11543 dBrHXXRatio1 = BrHXXRatio - 1.0;
11544 dBrHXXRatio2 = 0.0;
11545 } else if (fstate == 7){
11546 BrHXXRatio = (myNPbase->BrHZZRatio());
11547 dBrHXXRatio1 = BrHXXRatio - 1.0;
11548 dBrHXXRatio2 = 0.0;
11549 } else {
11550 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11551 }
11552
11553 //-- Production x Decay:
11554 if ((this->getModel()).isModelLinearized()){
11555 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11556 } else if((this->getModel()).isModelNPquadratic()){
11557 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11558 } else {
11559 return weight*(muProd)*(BrHXXRatio);
11560 }
11561
11562}
11563
11564// -----------------------------------------------------------------------------
11565
11566//AG:STXS2024
11567STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11568: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11569{
11570 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11571 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11572
11573}
11574
11575double STXS12_tH::computeThValue() //AG:modified
11576{
11577 //-- Production:
11578 double weight = 1.0; //If normalized to the SM
11579 double muProd = myNPbase->STXS12_tH(sqrt_s);
11580 double muProd1 = muProd -1.0;
11581 double muProd2 = 0.0;
11582
11583 //-- Decay:
11584 double BrHXXRatio = 1.0;
11585 double dBrHXXRatio1 = 0.0;
11586 double dBrHXXRatio2 = 0.0;
11587 if (fstate==0){
11588 // Use for Cross-section [pb] with no Higgs-boson decay
11589 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11590 } else if (fstate == 1){
11591 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11592 dBrHXXRatio1 = BrHXXRatio - 1.0;
11593 dBrHXXRatio2 = 0.0;
11594 } else if (fstate == 2){
11595 BrHXXRatio = (myNPbase->BrHgagaRatio());
11596 dBrHXXRatio1 = BrHXXRatio - 1.0;
11597 dBrHXXRatio2 = 0.0;
11598 } else if (fstate == 3){
11599 BrHXXRatio = (myNPbase->BrHbbRatio());
11600 dBrHXXRatio1 = BrHXXRatio - 1.0;
11601 dBrHXXRatio2 = 0.0;
11602 } else if (fstate == 4){
11603 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11604 dBrHXXRatio1 = BrHXXRatio - 1.0;
11605 dBrHXXRatio2 = 0.0;
11606 } else if (fstate == 5){
11607 BrHXXRatio = (myNPbase->BrHtautauRatio());
11608 dBrHXXRatio1 = BrHXXRatio - 1.0;
11609 dBrHXXRatio2 = 0.0;
11610 } else {
11611 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11612 }
11613
11614 //-- Production x Decay:
11615 if ((this->getModel()).isModelLinearized()){
11616 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11617 } else if((this->getModel()).isModelNPquadratic()){
11618 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11619 } else {
11620 return weight*(muProd)*(BrHXXRatio);
11621 }
11622
11623
11624}
11625
11626// -----------------------------------------------------------------------------
11627
11628
11629//-----------------------------------------------------------------------------------------
11630//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11631//-----------------------------------------------------------------------------------------
11632
11633
11634muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11635: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11636{
11637 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11638 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11639}
11640
11642{
11643 return myNPbase->muTHUggHgaga(sqrt_s);
11644}
11645
11646
11647muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11648: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11649{
11650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11651 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11652}
11653
11655{
11656 return myNPbase->muTHUVBFHgaga(sqrt_s);
11657}
11658
11659muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11660: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11661{
11662 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11663 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11664}
11665
11667{
11668 return myNPbase->muTHUZHgaga(sqrt_s);
11669}
11670
11671muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11672: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11673{
11674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11675 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11676}
11677
11679{
11680 return myNPbase->muTHUWHgaga(sqrt_s);
11681}
11682
11683muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11684: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11685{
11686 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11687 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11688}
11689
11691{
11692 return myNPbase->muTHUVHgaga(sqrt_s);
11693}
11694
11695muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11696: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11697{
11698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11699 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11700}
11701
11703{
11704 return myNPbase->muTHUttHgaga(sqrt_s);
11705}
11706
11707muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11708: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11709{
11710 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11711 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11712}
11713
11715{
11716 return myNPbase->muTHUggHZga(sqrt_s);
11717}
11718
11719muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11720: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11721{
11722 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11723 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11724}
11725
11727{
11728 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11729}
11730
11731muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11732: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11733{
11734 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11735 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11736}
11737
11739{
11740
11741 return myNPbase->muTHUVBFHZga(sqrt_s);
11742}
11743
11744muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11745: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11746{
11747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11748 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11749}
11750
11752{
11753 return myNPbase->muTHUZHZga(sqrt_s);
11754}
11755
11756muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11757: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11758{
11759 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11760 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11761}
11762
11764{
11765 return myNPbase->muTHUWHZga(sqrt_s);
11766}
11767
11768muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11769: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11770{
11771 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11772 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11773}
11774
11776{
11777 return myNPbase->muTHUVHZga(sqrt_s);
11778}
11779
11780muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11781: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11782{
11783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11784 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11785}
11786
11788{
11789 return myNPbase->muTHUttHZga(sqrt_s);
11790}
11791
11792muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11793: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11794{
11795 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11796 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11797}
11798
11800{
11801 return myNPbase->muTHUggHZZ(sqrt_s);
11802}
11803
11804muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11805: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11806{
11807 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11808 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11809}
11810
11812{
11813 return myNPbase->muTHUVBFHZZ(sqrt_s);
11814}
11815
11816muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11817: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11818{
11819 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11820 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11821}
11822
11824{
11825 return myNPbase->muTHUZHZZ(sqrt_s);
11826}
11827
11828muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11829: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11830{
11831 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11832 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11833}
11834
11836{
11837 return myNPbase->muTHUWHZZ(sqrt_s);
11838}
11839
11840muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11841: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11842{
11843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11844 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11845}
11846
11848{
11849 return myNPbase->muTHUVHZZ(sqrt_s);
11850}
11851
11852muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11853: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11854{
11855 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11856 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11857}
11858
11860{
11861 return myNPbase->muTHUttHZZ(sqrt_s);
11862}
11863
11864muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11865: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11866{
11867 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11868 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11869}
11870
11872{
11873 return myNPbase->muTHUggHZZ4l(sqrt_s);
11874}
11875
11876muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11877: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11878{
11879 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11880 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11881}
11882
11884{
11885 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11886}
11887
11888muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11889: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11890{
11891 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11892 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11893}
11894
11896{
11897 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11898}
11899
11900muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11901: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11902{
11903 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11904 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11905}
11906
11908{
11909 return myNPbase->muTHUZHZZ4l(sqrt_s);
11910}
11911
11912muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11913: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11914{
11915 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11916 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11917}
11918
11920{
11921 return myNPbase->muTHUWHZZ4l(sqrt_s);
11922}
11923
11924muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11925: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11926{
11927 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11928 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11929}
11930
11932{
11933 return myNPbase->muTHUVHZZ4l(sqrt_s);
11934}
11935
11936muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11937: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11938{
11939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11940 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11941}
11942
11944{
11945 return myNPbase->muTHUttHZZ4l(sqrt_s);
11946}
11947
11948muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11949: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11950{
11951 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11952 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11953}
11954
11956{
11957 return myNPbase->muTHUggHWW(sqrt_s);
11958}
11959
11960muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
11961: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11962{
11963 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11964 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
11965}
11966
11968{
11969 return myNPbase->muTHUVBFHWW(sqrt_s);
11970}
11971
11972muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
11973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11974{
11975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11976 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
11977}
11978
11980{
11981 return myNPbase->muTHUZHWW(sqrt_s);
11982}
11983
11984muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
11985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11986{
11987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11988 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
11989}
11990
11992{
11993 return myNPbase->muTHUWHWW(sqrt_s);
11994}
11995
11996muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
11997: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11998{
11999 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12000 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
12001}
12002
12004{
12005 return myNPbase->muTHUVHWW(sqrt_s);
12006}
12007
12008muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
12009: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12010{
12011 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12012 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
12013}
12014
12016{
12017 return myNPbase->muTHUttHWW(sqrt_s);
12018}
12019
12020muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12022{
12023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12024 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
12025}
12026
12028{
12030}
12031
12032muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12033: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12034{
12035 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12036 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
12037}
12038
12040{
12042}
12043
12044muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12045: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12046{
12047 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12048 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
12049}
12050
12052{
12053 return myNPbase->muTHUZHWW2l2v(sqrt_s);
12054}
12055
12056muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12057: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12058{
12059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12060 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
12061}
12062
12064{
12065 return myNPbase->muTHUWHWW2l2v(sqrt_s);
12066}
12067
12068muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12069: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12070{
12071 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12072 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
12073}
12074
12076{
12077 return myNPbase->muTHUVHWW2l2v(sqrt_s);
12078}
12079
12080muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12081: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12082{
12083 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12084 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
12085}
12086
12088{
12090}
12091
12092muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12093: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12094{
12095 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12096 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
12097}
12098
12100{
12101 return myNPbase->muTHUggHmumu(sqrt_s);
12102}
12103
12104muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12105: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12106{
12107 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12108 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
12109}
12110
12112{
12113 return myNPbase->muTHUVBFHmumu(sqrt_s);
12114}
12115
12116muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12118{
12119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12120 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
12121}
12122
12124{
12125 return myNPbase->muTHUZHmumu(sqrt_s);
12126}
12127
12128muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12129: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12130{
12131 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12132 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
12133}
12134
12136{
12137 return myNPbase->muTHUWHmumu(sqrt_s);
12138}
12139
12140muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12141: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12142{
12143 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12144 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
12145}
12146
12148{
12149 return myNPbase->muTHUVHmumu(sqrt_s);
12150}
12151
12152muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12153: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12154{
12155 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12156 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
12157}
12158
12160{
12161 return myNPbase->muTHUttHmumu(sqrt_s);
12162}
12163
12164muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12166{
12167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12168 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
12169}
12170
12172{
12174}
12175
12176muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12177: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12178{
12179 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12180 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
12181}
12182
12184{
12186}
12187
12188muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12189: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12190{
12191 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12192 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
12193}
12194
12196{
12197 return myNPbase->muTHUZHtautau(sqrt_s);
12198}
12199
12200muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12202{
12203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12204 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
12205}
12206
12208{
12209 return myNPbase->muTHUWHtautau(sqrt_s);
12210}
12211
12212muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12213: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12214{
12215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12216 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
12217}
12218
12220{
12221 return myNPbase->muTHUVHtautau(sqrt_s);
12222}
12223
12224muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12225: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12226{
12227 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12228 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
12229}
12230
12232{
12234}
12235
12236muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
12237: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12238{
12239 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12240 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
12241}
12242
12244{
12245 return myNPbase->muTHUggHbb(sqrt_s);
12246}
12247
12248muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
12249: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12250{
12251 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12252 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
12253}
12254
12256{
12257 return myNPbase->muTHUVBFHbb(sqrt_s);
12258}
12259
12260muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
12261: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12262{
12263 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12264 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
12265}
12266
12268{
12269 return myNPbase->muTHUZHbb(sqrt_s);
12270}
12271
12272muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
12273: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12274{
12275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12276 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
12277}
12278
12280{
12281 return myNPbase->muTHUWHbb(sqrt_s);
12282}
12283
12284muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
12285: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12286{
12287 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12288 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
12289}
12290
12292{
12293 return myNPbase->muTHUVHbb(sqrt_s);
12294}
12295
12296muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
12297: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12298{
12299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12300 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
12301}
12302
12304{
12305 return myNPbase->muTHUttHbb(sqrt_s);
12306}
12307
12308
12309muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12311{
12312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12313 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12314}
12315
12317{
12318
12319 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12320
12321}
12322
12323muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12324: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12325{
12326 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12327 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12328}
12329
12331{
12332
12333 return (myNPbase->muTHUVBFHinv(sqrt_s));
12334
12335}
12336
12337
12338muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12340{
12341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12342 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12343}
12344
12346{
12347
12348 return (myNPbase->muTHUVHBRinv(sqrt_s));
12349
12350}
12351
12352muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12353: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12354{
12355 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12356 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12357}
12358
12360{
12361 return (myNPbase->muTHUVHinv(sqrt_s));
12362}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1839
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1763
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3994
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3599
virtual const double cbminuscc() const
Definition: NPbase.h:2788
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:2974
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4269
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:2020
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4359
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2461
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1162
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3890
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2938
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2864
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2569
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:3034
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4005
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1634
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3379
virtual const double cVpluscb() const
Definition: NPbase.h:2770
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:2024
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3899
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1383
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1743
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1137
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4066
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4152
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3984
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3425
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1943
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1418
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:1113
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2211
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4098
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1523
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1212
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3474
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1559
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2129
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1710
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1650
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1811
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2876
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3628
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1779
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4251
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3776
virtual const double ccminusctau() const
Definition: NPbase.h:2806
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2888
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4143
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3504
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1775
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4386
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1690
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1916
virtual const double cgaplusct() const
Definition: NPbase.h:2752
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:3039
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2848
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:2006
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1246
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1767
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3416
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4368
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:4088
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2201
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1463
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4107
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:3049
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1939
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2828
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2868
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2872
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3785
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4048
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1799
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2149
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4161
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4197
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2942
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3454
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4224
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1666
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2918
virtual const double cgplusct() const
Definition: NPbase.h:2743
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1831
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3739
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2844
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1475
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:3022
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4017
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1723
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1731
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4305
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1638
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1751
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:2038
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1281
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3872
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3752
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4188
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3712
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2362
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2326
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2304
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1576
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1871
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1332
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3812
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1594
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3608
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2221
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:1997
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3794
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:2011
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4260
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4296
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3667
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3618
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:3026
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3648
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2909
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1875
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:3054
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2648
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1934
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1642
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:2015
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3398
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1755
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1739
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1678
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4413
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:1993
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1966
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2836
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3494
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1662
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2056
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1885
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3638
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1257
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1894
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3935
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1975
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2934
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3703
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2076
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2191
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3513
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1646
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:3010
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1803
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1686
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2958
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1488
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1295
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3803
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2066
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2698
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2840
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2578
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3369
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1771
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1175
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1747
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1835
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4422
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1851
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:2042
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4039
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3590
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1759
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4030
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3962
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3685
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3721
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1819
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2824
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1988
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2930
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1984
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1582
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2954
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3926
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1345
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3840
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2294
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1930
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1618
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2734
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2599
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3522
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1622
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3760
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3550
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2668
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4431
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2171
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3944
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1694
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1499
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1511
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3434
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3973
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2251
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1847
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4116
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1187
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3407
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2707
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:2970
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3917
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4314
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:3059
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2159
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3953
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:3002
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2897
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1727
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4125
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4170
virtual const double cbminusctau() const
Definition: NPbase.h:2797
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2630
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1407
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2139
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2371
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1150
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2913
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1702
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2716
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2962
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4057
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1200
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3908
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2086
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2096
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2659
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1588
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1855
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1735
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2884
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:1102
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3464
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1571
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3484
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2905
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3676
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1979
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1823
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:2990
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2109
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3851
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4206
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2231
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3694
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2515
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:3044
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1843
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2119
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2819
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1859
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4377
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2893
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1630
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:3014
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2832
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1783
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1670
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1682
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:2002
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1235
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4449
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1674
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2678
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1807
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1791
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3863
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1658
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2621
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2922
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4233
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3570
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4332
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2688
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3768
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2284
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1815
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:3030
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1371
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1395
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1898
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3389
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:4077
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4341
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1451
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:3064
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3444
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3830
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1535
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4242
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1827
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2608
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2470
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1654
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:2998
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2264
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1614
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4134
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3881
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2725
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2852
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2181
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2946
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2241
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1307
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1912
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1787
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3658
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:2982
virtual const double cgminuscga() const
Definition: NPbase.h:2761
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3357
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1889
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2880
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4179
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:3006
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1268
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1879
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3541
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3560
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:1125
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1609
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2639
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:1091
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1970
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4440
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double cVplusctau() const
Definition: NPbase.h:2779
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2950
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3730
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1224
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1903
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:2994
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1719
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4323
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1907
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1863
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1706
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2856
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1429
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4395
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1358
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:3018
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:2978
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4278
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1319
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3580
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2901
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4350
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1795
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1626
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1867
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:2986
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4404
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3532
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:2966
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1698
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3821
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2926
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1547
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4215
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2860
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeHvvss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase